diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml new file mode 100644 index 0000000000..262a9ee4be --- /dev/null +++ b/.github/FUNDING.yml @@ -0,0 +1 @@ +github: meshcore-dev diff --git a/boards/esp32-s3-devkitc-1-myboard.json b/boards/esp32-s3-devkitc-1-myboard.json new file mode 100644 index 0000000000..9b86ea4a5a --- /dev/null +++ b/boards/esp32-s3-devkitc-1-myboard.json @@ -0,0 +1,51 @@ +{ + "build": { + "arduino":{ + "ldscript": "esp32s3_out.ld", + "memory_type": "qio_opi", + "partitions": "elecrow_partitions.csv" + }, + "core": "esp32", + "extra_flags": [ + "-DBOARD_HAS_PSRAM", + "-DARDUINO_USB_MODE=1", + "-DARDUINO_RUNNING_CORE=1", + "-DARDUINO_EVENT_RUNNING_CORE=1" + ], + "f_cpu": "240000000L", + "f_flash": "80000000L", + "flash_mode": "qio", + "hwids": [ + [ + "0x303A", + "0x1001" + ] + ], + "mcu": "esp32s3", + "variant": "esp32s3" + }, + "connectivity": [ + "wifi" + ], + "debug": { + "default_tool": "esp-builtin", + "onboard_tools": [ + "esp-builtin" + ], + "openocd_target": "esp32s3.cfg" + }, + "frameworks": [ + "arduino", + "espidf" + ], + "name": "Espressif ESP32-S3-DevKitC-1-N8 -ELECROW", + "upload": { + "flash_size": "4MB", + "maximum_ram_size": 327680, + "maximum_size": 8388608, + "require_upload_port": true, + "speed": 921600 + }, + "url": "https://docs.espressif.com/projects/esp-idf/en/latest/esp32s3/hw-reference/esp32s3/user-guide-devkitc-1.html", + "vendor": "Espressif" +} diff --git a/docs/faq.md b/docs/faq.md index c04eb6aa22..ddf6960e32 100644 --- a/docs/faq.md +++ b/docs/faq.md @@ -111,7 +111,6 @@ Anyone is able to build anything they like on top of MeshCore without paying any - MeshCore Firmware on GitHub: [https://github.com/meshcore-dev/MeshCore](https://github.com/meshcore-dev/MeshCore) - MeshCore Companion Web App: [https://app.meshcore.nz](https://app.meshcore.nz) - MeshCore Map: [https://map.meshcore.io](https://map.meshcore.io) -- Andy Kirby's [MeshCore Intro Video](https://www.youtube.com/watch?v=t1qne8uJBAc) - Liam Cottle's [MeshCore Technical Presentation](https://www.youtube.com/watch?v=OwmkVkZQTf4) You need LoRa hardware devices to run MeshCore firmware as clients or server (repeater and room server). @@ -402,10 +401,7 @@ Another way to download map tiles is to use this Python script to get the tiles There is also a modified script that adds additional error handling and parallel downloads: - - -UK map tiles are available separately from Andy Kirby on his discord server: - + ### 4.8. Q: Where do the map tiles go? Once you have the tiles downloaded, copy the `\tiles` folder to the root of your T-Deck's SD card. @@ -563,10 +559,6 @@ pio run -e RAK_4631_Repeater ``` then you'll find `firmware.zip` in `.pio/build/RAK_4631_Repeater` -Andy also has a video on how to build using VS Code: -*How to build and flash Meshcore repeater firmware | Heltec V3* - *(Link referenced in the Discord post)* - ### 5.10. Q: Are there other MeshCore related open source projects? **A:** [Liam Cottle](https://liamcottle.net)'s MeshCore web client and MeshCore Javascript library are open source under MIT license. diff --git a/elecrow_partitions.csv b/elecrow_partitions.csv new file mode 100644 index 0000000000..61254fcab2 --- /dev/null +++ b/elecrow_partitions.csv @@ -0,0 +1,6 @@ +# Name, Type, SubType, Offset, Size, Flags +nvs, data, nvs, 0x9000, 0x5000, +otadata, data, ota, 0xe000, 0x2000, +app0, app, ota_0, 0x10000, 0x300000, +spiffs, data, spiffs, 0x310000,0xE0000, +coredump, data, coredump,0x3F0000,0x10000, \ No newline at end of file diff --git a/examples/companion_radio/MyMesh.cpp b/examples/companion_radio/MyMesh.cpp index c67bb68c9e..c6fa145d38 100644 --- a/examples/companion_radio/MyMesh.cpp +++ b/examples/companion_radio/MyMesh.cpp @@ -382,7 +382,7 @@ void MyMesh::onDiscoveredContact(ContactInfo &contact, bool is_new, uint8_t path p->path_len = mesh::Packet::copyPath(p->path, path, path_len); } - if (!is_new) dirty_contacts_expiry = futureMillis(LAZY_CONTACTS_WRITE_DELAY); // only schedule lazy write for contacts that are in contacts[] + dirty_contacts_expiry = futureMillis(LAZY_CONTACTS_WRITE_DELAY); // contact is in contacts[], schedule lazy write } static int sort_by_recent(const void *a, const void *b) { @@ -970,6 +970,10 @@ void MyMesh::begin(bool has_display) { const char *MyMesh::getNodeName() { return _prefs.node_name; } + +const char* MyMesh::getFirmwareVer() { return FIRMWARE_VERSION; } +const char* MyMesh::getBuildDate() { return FIRMWARE_BUILD_DATE; } + NodePrefs *MyMesh::getNodePrefs() { return &_prefs; } @@ -1975,6 +1979,22 @@ void MyMesh::enterCLIRescue() { Serial.println("========= CLI Rescue ========="); } +void MyMesh::handleCommand(const char* command) { + while (*command == ' ') command++; // skip leading space + if (strcmp(command, "erase") == 0) { + bool success = _store->formatFileSystem(); + if (success) { + Serial.println(" > erase done"); + } else { + Serial.println(" Error: erase failed"); + } + } else if (strcmp(command, "reboot") == 0) { + board.reboot(); // doesn't return + } else { + Serial.println(" Error: unknown command"); + } +} + void MyMesh::checkCLIRescueCmd() { int len = strlen(cli_command); while (Serial.available() && len < sizeof(cli_command)-1) { diff --git a/examples/companion_radio/MyMesh.h b/examples/companion_radio/MyMesh.h index f6a4ce40e9..c784b9d2bc 100644 --- a/examples/companion_radio/MyMesh.h +++ b/examples/companion_radio/MyMesh.h @@ -92,6 +92,8 @@ class MyMesh : public BaseChatMesh, public DataStoreHost { void startInterface(BaseSerialInterface &serial); const char *getNodeName(); + const char *getFirmwareVer(); + const char *getBuildDate(); NodePrefs *getNodePrefs(); uint32_t getBLEPin(); @@ -165,6 +167,7 @@ class MyMesh : public BaseChatMesh, public DataStoreHost { public: void savePrefs() { _store->savePrefs(_prefs, sensors.node_lat, sensors.node_lon); } + void handleCommand(const char* command); #if ENV_INCLUDE_GPS == 1 void applyGpsPrefs() { diff --git a/examples/companion_radio/task_clock.cpp b/examples/companion_radio/task_clock.cpp new file mode 100644 index 0000000000..752a5147cb --- /dev/null +++ b/examples/companion_radio/task_clock.cpp @@ -0,0 +1,25 @@ +#include + +#include "esp_log.h" +#include "uiDefines.h" +#include "uiVars.h" + +#define TAG "clock_task" + +void clock_task(void *pvParameters) { + + vTaskSuspend(NULL); + + ESP_LOGI(TAG, "Clock manager: Task running on core %d", xPortGetCoreID()); + + uiManager->clearDateTime(); + + // TODO: sync clock + while (1) { + // uiManager->updateDateTime( + // myClock->getTimeStruct() + // ); + // uiManager->updateValues(); + vTaskDelay(DELAY_CLOCK_TASK / portTICK_PERIOD_MS); + } +} \ No newline at end of file diff --git a/examples/companion_radio/task_lvgl.cpp b/examples/companion_radio/task_lvgl.cpp new file mode 100644 index 0000000000..d88b6cd38d --- /dev/null +++ b/examples/companion_radio/task_lvgl.cpp @@ -0,0 +1,19 @@ +#include + +#include "esp_log.h" +#include "uiDefines.h" +#include "uiVars.h" + +#define TAG "lvgl_task" + +void lvgl_task(void *pvParameters) { + + vTaskSuspend(NULL); + + ESP_LOGI(TAG, "UI manager: Task running on core %d", xPortGetCoreID()); + + while (1) { + lv_timer_handler(); + vTaskDelay(DELAY_LVGL_TASK / portTICK_PERIOD_MS); + } +} \ No newline at end of file diff --git a/examples/companion_radio/ui-new/UITask.cpp b/examples/companion_radio/ui-new/UITask.cpp index 6f363d7f96..cc19c265ba 100644 --- a/examples/companion_radio/ui-new/UITask.cpp +++ b/examples/companion_radio/ui-new/UITask.cpp @@ -698,7 +698,7 @@ void UITask::shutdown(bool restart){ _board->reboot(); } else { _display->turnOff(); - radio_driver.powerOff(); + //radio_driver.powerOff(); _board->powerOff(); } } diff --git a/examples/companion_radio/uiManager.cpp b/examples/companion_radio/uiManager.cpp new file mode 100644 index 0000000000..bdcd4dbbd7 --- /dev/null +++ b/examples/companion_radio/uiManager.cpp @@ -0,0 +1,805 @@ +#include + +#include "esp_log.h" +#include "uiDefines.h" +#include "uiVars.h" + +#include "uiManager.h" + +#include "../src/fonts/fonts.h" + +#include +#include + +#if defined(LANG_GR) +const char *UIManager::days[7] = {"Κυρ", "Δευ", "Τρι", "Τετ", "Πεμ", "Παρ", "Σαβ"}; +const char *UIManager::months[12] = {"Ιαν", "Φεβ", "Μαρ", "Απρ", "Μαι", "Ιουν", + "Ιουλ", "Αυγ", "Σεπ", "Οκτ", "Νοε", "Δεκ"}; +#elif defined(LANG_EN) +const char *UIManager::days[7] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}; +const char *UIManager::months[12] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", + "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}; +#endif + +#define TAG "UIManager" + +extern void handleCommand(char *msg); + +UIManager::UIManager() { + + tmp_buf = (char*)malloc(128); + + lv_disp_t * dispp = lv_disp_get_default(); + lv_theme_t * theme = lv_theme_default_init(dispp, lv_palette_main(LV_PALETTE_BLUE), lv_palette_main(LV_PALETTE_RED), + false, LV_FONT_DEFAULT); + lv_disp_set_theme(dispp, theme); + ui_Screen1_screen_init(); + ui____initial_actions0 = lv_obj_create(NULL); + lv_disp_load_scr(ui_Screen1); + +} + +void UIManager::format_time(uint32_t ts, char *buf, size_t len) +{ + time_t t = ts; + struct tm *tm_info = localtime(&t); + strftime(buf, len, "%H:%M:%S", tm_info); +} + +void UIManager::format_datetime(char *buf, size_t size, const struct tm *timeinfo) { + char tmp[64]; + strftime(tmp, sizeof(tmp), "%a, %d %b %Y", timeinfo); + + int wday = timeinfo->tm_wday; // 0=Κυρ ... 6=Σαβ + int mon = timeinfo->tm_mon; // 0=Ιαν ... 11=Δεκ + + // replace %a and %b with selected language + snprintf(buf, size, "%s, %02d %s %d", days[wday], timeinfo->tm_mday, months[mon], 1900 + timeinfo->tm_year); +} + +void UIManager::updateDateTime(const struct tm timeinfo) { + // TODO: Add to settings "Date format" + char date_str[50]; + format_datetime(date_str, sizeof(date_str), &timeinfo); + lv_label_set_text(ui_ValueDate, date_str); + + // TODO: Add to settings "Hour format" + strftime(tmp_buf, 50, "%H:%M", &timeinfo); // 24h format + //strftime(tmp_buf, 50, "%I:%M %p", &timeinfo); // 12h format + lv_label_set_text(ui_ValueTime, tmp_buf); + + // TODO: Add to settings "dim at night" + // TODO: Add to settings "dim hours" + // TODO: Add to settings "dim percentage" + if (timeinfo.tm_hour > 21 || timeinfo.tm_hour < 7) { + setNightMode(true); + } else { + setNightMode(false); + } +} + +void UIManager::clearDateTime() { + #if defined(LANG_EN) + uiManager->updateInfo("Clock sync...", COLOR_WHITE); + #elif defined(LANG_GR) + uiManager->updateInfo("Συγχρονισμός ώρας...", COLOR_WHITE); + #endif + lv_label_set_text(ui_ValueDate, "--- --/--/----"); + lv_label_set_text(ui_ValueTime, "--:--"); +} + +void UIManager::timestampToTime(time_t timestamp, char *buffer, size_t buffer_size) { + struct tm *time_info; + time_info = localtime(×tamp); + strftime(buffer, buffer_size, "%H:%M", time_info); +} + +const char* UIManager::convertDegreesToDirection(int degrees) { + // Normalize degrees to [0, 360) + degrees = degrees % 360; + if (degrees < 0) degrees += 360; + +#if defined(LANG_EN) + static constexpr const char* dirs[] = {"N", "NE", "E", "SE", "S", "SW", "W", "NW"}; +#elif defined(LANG_GR) + static constexpr const char* dirs[] = {"Β", "ΒΑ", "Α", "ΝΑ", "Ν", "ΝΔ", "Δ", "ΒΔ"}; +#else + #error "No Language defined!" +#endif + + // Each direction covers 45°, starting at N = 0° + int index = static_cast((degrees + 22.5) / 45.0) % 8; + return dirs[index]; +} + + +int UIManager::windSpeedToBeaufort(float speed) { + static const float limits[] = { + 0.5, 1.5, 3.3, 5.5, 7.9, 10.7, + 13.8, 17.1, 20.7, 24.4, 28.4, 32.6 + }; + + for (int i = 0; i < 12; ++i) + if (speed < limits[i]) + return i; + return 12; +} + +void UIManager::updateValues() { + lv_label_set_text(ui_ValueTime, "--:--"); +} + +void UIManager::updateInfo(const char *str, uint32_t color) { + // lv_label_set_text(ui_ValueLastUpdate, str); + // lv_obj_set_style_text_color(ui_ValueLastUpdate, lv_color_hex(color), LV_PART_MAIN | LV_STATE_DEFAULT); +} + +void UIManager::addChatBubble(const char *time_str, const char *sender, const char *msg,bool is_self) +{ + // Remove oldest + if (chat_count >= MAX_CHAT_MESSAGES) { + lv_obj_del(chat_items[0]); + memmove(&chat_items[0], &chat_items[1], sizeof(lv_obj_t*) * (MAX_CHAT_MESSAGES - 1)); + chat_count--; + } + + // Row container (align bubble left/right) + lv_obj_t *row = lv_obj_create(ui_ChannelMessages); + lv_obj_set_width(row, lv_pct(100)); + lv_obj_set_height(row, LV_SIZE_CONTENT); + lv_obj_set_style_bg_opa(row, 0, 0); + lv_obj_set_style_pad_all(row, 0, 0); + lv_obj_set_style_border_width(row, 0, 0); + lv_obj_set_style_outline_width(row, 0, 0); + lv_obj_clear_flag(row, LV_OBJ_FLAG_SCROLLABLE); + + lv_obj_set_flex_flow(row, LV_FLEX_FLOW_ROW); + lv_obj_set_flex_align(row, + is_self ? LV_FLEX_ALIGN_END : LV_FLEX_ALIGN_START, + LV_FLEX_ALIGN_START, + LV_FLEX_ALIGN_START); + + // Bubble container (COLUMN) + lv_obj_t *bubble = lv_obj_create(row); + lv_obj_set_width(bubble, lv_pct(85)); + lv_obj_set_height(bubble, LV_SIZE_CONTENT); + lv_obj_set_style_radius(bubble, 12, 0); + lv_obj_set_style_pad_all(bubble, 10, 0); + lv_obj_set_style_bg_color(bubble, + is_self ? lv_color_hex(0x1E88E5) : lv_color_hex(0x2C2C2C), 0); + + // IMPORTANT: vertical layout inside bubble + lv_obj_set_flex_flow(bubble, LV_FLEX_FLOW_COLUMN); + lv_obj_set_flex_align(bubble, + LV_FLEX_ALIGN_START, + LV_FLEX_ALIGN_START, + LV_FLEX_ALIGN_START); + + // Header row (sender + time) + lv_obj_t *hdr = lv_obj_create(bubble); + lv_obj_set_width(hdr, lv_pct(100)); + lv_obj_set_height(hdr, LV_SIZE_CONTENT); + lv_obj_set_style_bg_opa(hdr, 0, 0); + lv_obj_set_style_border_width(hdr, 0, 0); + lv_obj_set_style_pad_all(hdr, 0, 0); + lv_obj_set_style_outline_width(hdr, 0, 0); + + lv_obj_set_flex_flow(hdr, LV_FLEX_FLOW_ROW); + lv_obj_set_flex_align(hdr, + LV_FLEX_ALIGN_SPACE_BETWEEN, + LV_FLEX_ALIGN_START, //LV_FLEX_ALIGN_CENTER, // Ευθυγράμμιση ονόματος/ώρας στον κάθετο άξονα + LV_FLEX_ALIGN_START); + + lv_obj_t *lbl_sender = lv_label_create(hdr); + lv_label_set_text(lbl_sender, sender); + lv_obj_set_style_text_color(lbl_sender, + is_self ? lv_color_hex(0xE3F2FD) : lv_color_hex(0x90CAF9), 0); + lv_obj_set_style_text_font(lbl_sender, &lv_font_arial_22, 0); + + lv_obj_t *lbl_time = lv_label_create(hdr); + lv_label_set_text(lbl_time, time_str); + lv_obj_set_style_text_color(lbl_time, lv_color_hex(0xB0B0B0), 0); + lv_obj_set_style_text_font(lbl_time, &lv_font_arial_20, 0); + + // Message body (below header) + lv_obj_t *lbl_msg = lv_label_create(bubble); + lv_label_set_text(lbl_msg, msg); + lv_label_set_long_mode(lbl_msg, LV_LABEL_LONG_WRAP); + lv_obj_set_width(lbl_msg, lv_pct(100)); + + lv_obj_set_style_text_color(lbl_msg, lv_color_hex(0xFFFFFF), 0); + lv_obj_set_style_text_font(lbl_msg, &lv_font_arial_26, 0); + + // Spacing between header and text + //lv_obj_set_style_margin_top(lbl_msg, 6, 0); + lv_obj_set_style_pad_row(bubble, 6, 0); + + chat_items[chat_count++] = row; + + lv_obj_scroll_to_view(row, LV_ANIM_ON); + } + +void UIManager::addPrivateChatBubble(const char *time_str, const char *msg, bool is_self) { + + lv_obj_set_style_pad_bottom(ui_ContactMessages, 20, 0); + + // 1. Row container + lv_obj_t* row = LvObj(ui_ContactMessages) + .width(lv_pct(100)) + .height(LV_SIZE_CONTENT) + .bgOpa(0) + .border(0) + .padAll(4) + .scrollable(false) + .flexFlow(LV_FLEX_FLOW_ROW) + .flexAlign( + is_self ? LV_FLEX_ALIGN_END : LV_FLEX_ALIGN_START, + LV_FLEX_ALIGN_START, + LV_FLEX_ALIGN_START + ); + + // 2. Aligner (Column) - label and time + lv_obj_t* aligner = LvObj(row) + .width(LV_SIZE_CONTENT) + .height(LV_SIZE_CONTENT) + .bgOpa(0) + .border(0) + .padAll(0) + .scrollable(false) + .flexFlow(LV_FLEX_FLOW_ROW) + .flexAlign( + is_self ? LV_FLEX_ALIGN_END : LV_FLEX_ALIGN_START, + LV_FLEX_ALIGN_START, + LV_FLEX_ALIGN_START + ); + lv_obj_set_style_pad_row(aligner, 4, 0); + + // 3. Το Label-Bubble (Ενοποιημένο) + lv_obj_t *lbl_msg = lv_label_create(aligner); + + // Long mode για wrap + lv_label_set_long_mode(lbl_msg, LV_LABEL_LONG_WRAP); + lv_label_set_text(lbl_msg, msg); + lv_obj_set_style_text_font(lbl_msg, &lv_font_arial_22, 0); + + // Fixed max width για wrap + lv_obj_set_width(lbl_msg, 400); // max πλάτος + lv_obj_set_height(lbl_msg, LV_SIZE_CONTENT); // αυτόματο ύψος + + // Bubble style + lv_obj_set_style_bg_opa(lbl_msg, LV_OPA_COVER, 0); + lv_obj_set_style_radius(lbl_msg, 12, 0); + lv_obj_set_style_pad_all(lbl_msg, 12, 0); + + if(is_self) { + lv_obj_set_style_bg_color(lbl_msg, lv_color_hex(0x1E88E5), 0); + lv_obj_set_style_text_color(lbl_msg, lv_color_hex(0xFFFFFF), 0); + } else { + lv_obj_set_style_bg_color(lbl_msg, lv_color_hex(0xFFFFFF), 0); + lv_obj_set_style_text_color(lbl_msg, lv_color_hex(0x000000), 0); + } + + // 4. Η Ώρα + lv_obj_t *lbl_time = lv_label_create(aligner); + lv_label_set_text(lbl_time, time_str); + lv_obj_set_style_text_color(lbl_time, lv_color_hex(0x808080), 0); + lv_obj_set_style_text_font(lbl_time, &lv_font_arial_14, 0); + + lv_obj_scroll_to_view(row, LV_ANIM_ON); +} + +void UIManager::getInitials(const char *name, char *out) { + out[0] = 0; + if (!name || !name[0]) return; + + const char *p = name; + while (*p && !isalnum((unsigned char)*p)) { + p++; + } + + char first = (*p) ? *p : name[0]; + char second = 0; + const char *space = strchr(name, ' '); + + if (space) { + const char *s = space + 1; + while (*s && !isalnum((unsigned char)*s)) { + s++; + } + if (*s) { + second = *s; + } + } + + out[0] = toupper((unsigned char)first); + if (second) { + out[1] = toupper((unsigned char)second); + out[2] = 0; + } else { + out[1] = 0; + } +} + +void UIManager::formatLastSeen(uint32_t ts, char *out, size_t len) { + if (ts == 0) { + snprintf(out, len, "Never"); + return; + } + + time_t t = (time_t)ts; + struct tm *tm = localtime(&t); + + if (tm == nullptr) { + snprintf(out, len, "Unknown"); + return; + } + + snprintf(out, len, "%02d:%02d %02d/%02d/%02d", + tm->tm_hour, + tm->tm_min, + tm->tm_mday, + tm->tm_mon + 1, + (tm->tm_year + 1900) % 100); // Προσθέτουμε το 1900 και παίρνουμε τα τελευταία 2 ψηφία +} + +static void onContactClick(lv_event_t *e) +{ + UIManager *self = (UIManager*) lv_event_get_user_data(e); + if(self) self->handleContactClick(e); +} + +void UIManager::handleContactClick(lv_event_t *e) +{ + lv_obj_t *row = lv_event_get_target(e); + ContactInfo *c = (ContactInfo*) lv_obj_get_user_data(row); + + Serial.printf("Clicked: %s\n", c->name); +} + +void UIManager::addContactToUI(ContactInfo c) +{ + const int ROW_W = 200; + const int ROW_H = 64; + const int AVATAR = 44; + const int PAD = 4; + + // ============================ + // List row button + // ============================ + lv_obj_t* btn = lv_list_add_btn(ui_Contacts, nullptr, nullptr); + + LvObj(btn, true) + .size(ROW_W, ROW_H) + .padAll(0) + .bgColor(0x000000) + .bgOpa(LV_OPA_COVER) + .noDecor() + .border(1) + .scrollable(false); + + lv_obj_set_layout(btn, 0); + lv_obj_set_style_border_side(btn, LV_BORDER_SIDE_BOTTOM, 0); + lv_obj_set_style_border_color(btn, lv_color_hex(0x222222), 0); + lv_obj_set_style_bg_color(btn, lv_color_hex(0x111111), LV_STATE_PRESSED); + + // Store ContactInfo + auto* store = new ContactInfo(c); + lv_obj_set_user_data(btn, store); + + lv_obj_add_event_cb(btn, onContactClick, LV_EVENT_CLICKED, this); + + // ============================ + // Avatar container (hidden when SHOW_CONTACT_AVATAR is false) + // ============================ +#ifdef SHOW_CONTACT_AVATAR + lv_obj_t* content = LvObj(btn) + .size(ROW_H, ROW_H) + .position(0, 0) + .padAll(0) + .bgOpa(LV_OPA_TRANSP) + .border(0) + .scrollable(false) + .raw(); + + // Avatar circle + lv_obj_t* avatar = LvObj(content) + .size(AVATAR, AVATAR) + .position(0, 10) + .radius(LV_RADIUS_CIRCLE) + .bgColor(0x4A90E2) + .border(0) + .raw(); + + // Initials + char initials[4]; + if (c.type == ADV_TYPE_REPEATER) { + strcpy(initials, "(R)"); + } else { + getInitials(c.name, initials); + } + + LvLabel(avatar) + .text(initials) + .font(&lv_font_arial_22) + .textColor(0xFFFFFF) + .align(LV_ALIGN_CENTER); +#endif + + // ============================ + // Text column + // ============================ +#ifdef SHOW_CONTACT_AVATAR + int text_x = PAD + AVATAR + PAD; +#else + int text_x = 0; +#endif + int text_w = ROW_W - text_x - PAD; + + lv_obj_t* text_col = LvObj(btn) + .position(text_x, 0) + .size(text_w, ROW_H - PAD) + .padAll(0) + .bgOpa(LV_OPA_TRANSP) + .border(0) + .scrollable(false) + .raw(); + + // Name label + LvLabel(text_col) + .text(c.name) + .position(0, PAD + 4) + .width(text_w) + .font(&lv_font_arial_20) + .textColor(0xFFFFFF) + .wrap(false); + + // Last seen + char lastSeen[32]; + formatLastSeen(c.lastmod, lastSeen, sizeof(lastSeen)); + + LvLabel(text_col) + .text(lastSeen) + .position(0, PAD + 32) + .width(text_w) + .font(&lv_font_arial_16) + .textColor(0x888888) + .wrap(false); + + // ============================ + // Disable child clicks + // ============================ +#ifdef SHOW_CONTACT_AVATAR + LvObj(avatar, true).clickable(false); +#endif + LvObj(text_col, true).clickable(false); +} + +void UIManager::onShowKeyboard() +{ + LvKeyboard(ui_Keyboard, true).show(true); + LvObj(ui_DimOverlay, true).clickable(true); + LvObj(ui_ChannelInput, true).positionY(channelInputBaseKeybOnY); + LvObj(ui_SendBtn, true).positionY(channelInputBaseKeybOnY); +} + +void UIManager::onHideKeyboard() +{ + LvKeyboard(ui_Keyboard, true).show(false); + LvObj(ui_DimOverlay, true).clickable(false); + LvObj(ui_ChannelInput, true).positionY(channelInputBaseY); + LvObj(ui_SendBtn, true).positionY(channelInputBaseY); +} + +static void s_onChannelInputFocus(lv_event_t *e) +{ + UIManager *self = (UIManager*) lv_event_get_user_data(e); + if(self) self->onChannelInputFocus(e); +} + +void UIManager::onChannelInputFocus(lv_event_t* e) +{ + lv_obj_t* ta = lv_event_get_target(e); + if(!ui_Keyboard || !ta) return; + + lv_keyboard_set_textarea(ui_Keyboard, ta); + onShowKeyboard(); +} + +static void s_onSendClick(lv_event_t *e) +{ + UIManager *self = (UIManager*) lv_event_get_user_data(e); + if(self) self->onSendClick(e); +} + +void UIManager::onSendClick(lv_event_t* e) +{ + + char fullMessage[260]; + char msgCopy[200]; + + const char* msg = lv_textarea_get_text(ui_ChannelInput); + if(msg == NULL || msg[0] == '\0') return; + + strncpy(msgCopy, msg, sizeof(msgCopy) - 1); + msgCopy[sizeof(msgCopy) - 1] = '\0'; + + lv_textarea_set_text(ui_ChannelInput, ""); + + snprintf(fullMessage, sizeof(fullMessage), "public %s", msgCopy); + //handleCommand(fullMessage); + handleCommand(msgCopy); + + char time_buf[16]; + time_t now = time(NULL); + struct tm t; + localtime_r(&now, &t); + + sprintf(time_buf, "%02d:%02d:%02d\n", t.tm_hour, t.tm_min, t.tm_sec); + addChatBubble(time_buf, "Me", msgCopy, true); + + onHideKeyboard(); +} + +static void s_onKeyboardEvent(lv_event_t *e) +{ + UIManager *self = (UIManager*) lv_event_get_user_data(e); + if(self) self->onKeyboardEvent(e); +} + +void UIManager::onKeyboardEvent(lv_event_t* e) +{ + lv_event_code_t code = lv_event_get_code(e); + + if(code == LV_EVENT_READY || code == LV_EVENT_CANCEL) + { + LvKeyboard(ui_Keyboard, true).show(false); + + LvObj(ui_ChannelInput, true).positionY(channelInputBaseY); + LvObj(ui_SendBtn, true).positionY(channelInputBaseY); + + LvObj(ui_DimOverlay, true) + .bgOpa(0) + .clickable(false); + } +} + + +static void s_onDimOverlayClick(lv_event_t *e) +{ + UIManager *self = (UIManager*) lv_event_get_user_data(e); + if(self) self->onDimOverlayClick(e); +} + +void UIManager::onDimOverlayClick(lv_event_t* e) +{ + onHideKeyboard(); +} + +static void onScrollBeginEvent(lv_event_t *e) +{ + UIManager *self = (UIManager*) lv_event_get_user_data(e); + if(self) self->scroll_begin_event(e); +} + +void UIManager::scroll_begin_event(lv_event_t *e) +{ + if (lv_event_get_code(e) == LV_EVENT_SCROLL_BEGIN) { + lv_anim_t* a = (lv_anim_t*)lv_event_get_param(e); + if (a) a->time = 0; + + } +} + +void UIManager::ui_Screen1_screen_init(void) +{ + //lv_disp_set_rotation(disp, LV_DISP_ROT_90); + //ui_Screen1 = lv_obj_create(NULL); + + ui_Screen1 = LvObj(NULL) + .scrollable(false) + .bgColor(0x000000) + .bgOpa(255); + + LvTabView tabView(ui_Screen1); + tabView + .size(480, 480) + .align(LV_ALIGN_CENTER) + .bgColor(0x000000) + .contentNoScroll() + .tabBtnBg(0x424242) + .tabBtnText(0xFFFFFF, &lv_font_arial_18); + + ui_TabView1 = tabView.raw(); + + #if defined(LANG_EN) + ui_TabPageHome = tabView.addTab("Home"); + ui_TabPageContacts = tabView.addTab("Contacts"); + ui_TabPageChannels = tabView.addTab("Channels"); + ui_TabPageSettings = tabView.addTab("Settings"); + #elif defined(LANG_GR) + ui_TabPageHome = tabView.addTab("Αρχική"); + ui_TabPageContacts = tabView.addTab("Επαφές"); + ui_TabPageChannels = tabView.addTab("Κανάλια"); + ui_TabPageSettings = tabView.addTab("Ρυθμίσεις"); + #endif + + LvObj(ui_TabPageHome) + .scrollable(false) + .bgOpa(0) + .bgColor(0x000000); + LvObj(ui_TabPageContacts) + .scrollable(false) + .bgOpa(0) + .bgColor(0x000000); + LvObj(ui_TabPageChannels) + .scrollable(false) + .bgOpa(0) + .bgColor(0x000000); + LvObj(ui_TabPageSettings) + .scrollable(false) + .bgOpa(0) + .bgColor(0x000000); + + ui_ValueDate = LvLabel(ui_TabPageHome) + .text("--- --/--/----") + .width(LV_SIZE_CONTENT) + .height(LV_SIZE_CONTENT) + .font(&lv_font_arial_40) + .textColor(0xFFFFFF) + .opa(255) + .align(LV_ALIGN_CENTER) + .position(0, -165); + + + ui_ValueTime = LvLabel(ui_TabPageHome) + .text("--:--") + .width(LV_SIZE_CONTENT) + .height(LV_SIZE_CONTENT) + .font(&lv_font_arial_48) + .textColor(0xFFFFFF) + .opa(255) + .align(LV_ALIGN_CENTER) + .position(0, -100); + + ui_Contacts = LvList(ui_TabPageContacts) + .width(250) + .height(400) + .align(LV_ALIGN_CENTER) + .position(-274, 0) + .transparent() + .raw(); + + lv_obj_set_style_bg_opa(ui_Contacts, LV_OPA_TRANSP, 0); + lv_obj_set_style_border_width(ui_Contacts, 0, 0); + lv_obj_set_style_outline_width(ui_Contacts, 0, 0); + lv_obj_set_style_shadow_width(ui_Contacts, 0, 0); + //lv_obj_set_scrollbar_mode(ui_Contacts, LV_SCROLLBAR_MODE_OFF); + lv_obj_set_style_bg_opa(ui_Contacts, LV_OPA_TRANSP, LV_PART_ITEMS); + lv_obj_set_style_border_width(ui_Contacts, 0, LV_PART_ITEMS); + + ui_ContactMessages = LvList(ui_TabPageContacts) + .width(500) + .height(400) + .align(LV_ALIGN_CENTER) + .position(124, 0) + .transparent() + .raw(); + + lv_obj_set_style_bg_color(ui_ContactMessages, lv_color_hex(0), 0); + lv_obj_set_style_bg_opa(ui_ContactMessages, LV_OPA_TRANSP, 0); + lv_obj_set_style_border_width(ui_ContactMessages, 0, 0); + lv_obj_set_style_outline_width(ui_ContactMessages, 0, 0); + lv_obj_set_style_shadow_width(ui_ContactMessages, 0, 0); + //lv_obj_set_scrollbar_mode(ui_ContactMessages, LV_SCROLLBAR_MODE_OFF); + lv_obj_set_style_bg_opa(ui_ContactMessages, LV_OPA_TRANSP, LV_PART_ITEMS); + lv_obj_set_style_border_width(ui_ContactMessages, 0, LV_PART_ITEMS); + + // LvObj(ui_TabPageContacts) + // .size(2, 400) + // .position(222, 0) + // .bgColor(0x444444) + // .border(0) + // .scrollable(false) + // .radius(0); + + ui_Channels = LvDropdown(ui_TabPageChannels) + .options("Public") + .width(291) + .align(LV_ALIGN_CENTER) + .position(-243, -182) + .clickable(true) + .raw(); + + ui_ChannelMessages = LvList(ui_TabPageChannels) + .width(780) + .height(280) + .align(LV_ALIGN_CENTER) + .transparent() + .padRow(10) + .position(0, 0) + .bgColor(0) + .bgOpa(0) + .border(0) + .noDecor() + .raw(); + + //lv_obj_set_scrollbar_mode(ui_ChannelMessages, LV_SCROLLBAR_MODE_OFF); + lv_obj_set_style_bg_opa(ui_ChannelMessages, LV_OPA_TRANSP, LV_PART_ITEMS); + lv_obj_set_style_border_width(ui_ChannelMessages, 0, LV_PART_ITEMS); + + ui_ChannelDivider = LvObj(ui_TabPageChannels) + .size(780, 1) + .align(LV_ALIGN_CENTER) + .position(0, 150) + .bgColor(0x444444) + .border(0) + .raw(); + + ui_DimOverlay = LvObj(ui_Screen1) + .size(lv_pct(100), lv_pct(100)) + .align(LV_ALIGN_CENTER) + .bgColor(0x000000) + .bgOpa(0) + .bringToFront() + .onClick(s_onDimOverlayClick, this) + .scrollable(false) + .clickable(true) + .raw(); + lv_obj_remove_style_all(ui_DimOverlay); // no border/padding + lv_obj_clear_flag(ui_DimOverlay, LV_OBJ_FLAG_SCROLL_CHAIN_HOR); + lv_obj_clear_flag(ui_DimOverlay, LV_OBJ_FLAG_SCROLL_CHAIN_VER); + + + ui_ChannelInput = LvTextArea(ui_TabPageChannels) + .size(670, 40) + .align(LV_ALIGN_CENTER) + .position(-50, channelInputBaseY) + .oneLine(true) + #if defined(LANG_EN) + .placeholder("Write message...") + #elif defined(LANG_GR) + .placeholder("Γράψε μήνυμα...") + #endif + .font(&lv_font_arial_20) + .bgColor(0x111111) + .textColor(0xFFFFFF) + .borderColor(0x444444) + .borderWidth(1) + .radius(6) + .onFocus(s_onChannelInputFocus, this) + .raw(); + + ui_SendBtn = LvButton(ui_TabPageChannels) + .size(90, 42) + .align(LV_ALIGN_CENTER) + .position(350, channelInputBaseY) + .bgColor(0x3A7AFE) + .onClick(s_onSendClick, this) + .raw(); + + iu_SendLabel = LvLabel(ui_SendBtn) + #if defined(LANG_EN) + .text("Send") + #elif defined(LANG_GR) + .text("Αποστολή") + #endif + .font(&lv_font_arial_18); + lv_obj_center(iu_SendLabel); + + ui_Keyboard = LvKeyboard(lv_layer_top()) + .size(480, 200) + .align(LV_ALIGN_BOTTOM_MID) + .show(false) + .onEvent(s_onKeyboardEvent, this); +} + +void UIManager::setNightMode(bool night) { + + if (!ui_DimOverlay) return; + if (night) { + lv_obj_set_style_bg_opa(ui_DimOverlay, 192, 0); // 75% dark + } else { + lv_obj_set_style_bg_opa(ui_DimOverlay, 0, 0); // none + } +} + diff --git a/examples/companion_radio/uiTasks.cpp b/examples/companion_radio/uiTasks.cpp new file mode 100644 index 0000000000..b552204961 --- /dev/null +++ b/examples/companion_radio/uiTasks.cpp @@ -0,0 +1,50 @@ +#include + +#include "esp_log.h" +#include "uiDefines.h" +#include "uiTasks.h" +#include "uiVars.h" + +// Tasks +TaskHandle_t t_core0_lvgl; +TaskHandle_t t_core1_clock; +TaskHandle_t t_core1_core; + +#define TAG "createTasks" + +void createTasks() { + Serial.println("Creating Tasks..."); + + xTaskCreatePinnedToCore( + lvgl_task, // Task function. + "LVGL_Manager", // Name of task. + 10000, // Stack size of task + NULL, // Parameter of the task + 5, // Priority of the task + &t_core0_lvgl, // Task handle to keep track of created task + 0); // Pin task to core 0 + + xTaskCreatePinnedToCore( + core_task, // Task function. + "MeshCore", // Name of task. + 10000, // Stack size of task + NULL, // Parameter of the task + 4, // Priority of the task + &t_core1_core, // Task handle to keep track of created task + 1); // Pin task to core 1 + + xTaskCreatePinnedToCore( + clock_task, // Task function. + "CLOCK_Manager", // Name of task. + 10000, // Stack size of task + NULL, // Parameter of the task + 4, // Priority of the task + &t_core1_clock, // Task handle to keep track of created task + 1); // Pin task to core 1 + + ESP_LOGD(TAG, "All tasks created\nStarting tasks..."); + + vTaskResume(t_core0_lvgl); + vTaskResume(t_core1_clock); + +} diff --git a/examples/simple_secure_chat/main.cpp b/examples/simple_secure_chat/main.cpp index d50667368c..dfefe2699b 100644 --- a/examples/simple_secure_chat/main.cpp +++ b/examples/simple_secure_chat/main.cpp @@ -158,13 +158,13 @@ class MyMesh : public BaseChatMesh, ContactVisitor { } void setClock(uint32_t timestamp) { - uint32_t curr = getRTCClock()->getCurrentTime(); - if (timestamp > curr) { + //uint32_t curr = getRTCClock()->getCurrentTime(); + //if (timestamp > curr) { getRTCClock()->setCurrentTime(timestamp); Serial.println(" (OK - clock set!)"); - } else { - Serial.println(" (ERR: clock cannot go backwards)"); - } + //} else { + // Serial.println(" (ERR: clock cannot go backwards)"); + //} } void importCard(const char* command) { diff --git a/examples/simple_secure_chat_ui/main.cpp b/examples/simple_secure_chat_ui/main.cpp new file mode 100644 index 0000000000..7356cdb954 --- /dev/null +++ b/examples/simple_secure_chat_ui/main.cpp @@ -0,0 +1,1265 @@ +#include // needed for PlatformIO +#include +#include +#include + +#if defined(NRF52_PLATFORM) + #include +#elif defined(RP2040_PLATFORM) + #include +#elif defined(ESP32) + #include +#endif + +#include +#include +#include +#include +#include +#include + +/* ---------------------------------- CONFIGURATION ------------------------------------- */ + +#define FIRMWARE_VER_TEXT "v2 (build: 4 Feb 2025)" + +#ifndef LORA_FREQ + #define LORA_FREQ 869.525 +#endif +#ifndef LORA_BW + #define LORA_BW 250 +#endif +#ifndef LORA_SF + #define LORA_SF 11 +#endif +#ifndef LORA_CR + #define LORA_CR 5 +#endif +#ifndef LORA_TX_POWER + #define LORA_TX_POWER 20 +#endif + +#ifndef MAX_CONTACTS + #define MAX_CONTACTS 100 +#endif + +#include + +#include "esp_log.h" +#include +#include +#ifndef SEEED_SENSECAP_INDICATOR +#include +#include +#endif + +#include "../src/fonts/fonts.h" +#include "../lvgl/lvgl.h" + +#include "../include/uiExternals.h" +#include "../include/lgfx.h" +#include "../include/uiDefines.h" +#include "../include/uiManager.h" +#include "../include/uiTasks.h" +#include "uiTouch.h" +#include "messageStore.h" + +#define TAG "main" + +#define SEND_TIMEOUT_BASE_MILLIS 500 +#define FLOOD_SEND_TIMEOUT_FACTOR 16.0f +#define DIRECT_SEND_PERHOP_FACTOR 6.0f +#define DIRECT_SEND_PERHOP_EXTRA_MILLIS 250 + +#define PUBLIC_GROUP_PSK "izOH6cXN6mrJ5e26oRXNcg==" + +static uint32_t screenWidth; +static uint32_t screenHeight; +static lv_disp_draw_buf_t draw_buf; +static lv_color_t disp_draw_buf[800 * 480 / 10]; +//static lv_color_t disp_draw_buf; +static lv_disp_drv_t disp_drv; + +UIManager *uiManager; + +SemaphoreHandle_t semaphoreData; + +volatile bool g_clock_synced = false; + +TwoWire I2Cone = TwoWire(0); +#ifndef SEEED_SENSECAP_INDICATOR +Adafruit_SSD1306 display = Adafruit_SSD1306(128, 64, &I2Cone, OLED_RESET); +#endif + +SPIClass& spi = SPI; +uint16_t touchCalibration_x0 = 300, touchCalibration_x1 = 3600, touchCalibration_y0 = 300, touchCalibration_y1 = 3600; +uint8_t touchCalibration_rotate = 1, touchCalibration_invert_x = 2, touchCalibration_invert_y = 0; + +void format_time(uint32_t ts, char *buf, size_t len) +{ + time_t t = ts; + struct tm *tm_info = localtime(&t); + strftime(buf, len, "%H:%M:%S", tm_info); +} + +void parse_group_message(const char *input, + char *sender_out, size_t sender_len, + char *msg_out, size_t msg_len) +{ + const char *sep = strchr(input, ':'); + + if (!sep) { + strncpy(sender_out, "Unknown", sender_len); + strncpy(msg_out, input, msg_len); + return; + } + + size_t name_len = sep - input; + if (name_len >= sender_len) name_len = sender_len - 1; + + strncpy(sender_out, input, name_len); + sender_out[name_len] = 0; + + // Skip ": " + const char *msg_start = sep + 1; + if (*msg_start == ' ') msg_start++; + + strncpy(msg_out, msg_start, msg_len); +} + +// Elecrow Display callbacks +/* Display flushing */ +static uint32_t s_flush_count = 0; +void my_disp_flush(lv_disp_drv_t *disp, const lv_area_t *area, lv_color_t *color_p) +{ + uint32_t w = (area->x2 - area->x1 + 1); + uint32_t h = (area->y2 - area->y1 + 1); + + s_flush_count++; + if (s_flush_count <= 3) { + Serial.printf("[display] flush #%u x=%d y=%d w=%d h=%d\n", + s_flush_count, area->x1, area->y1, w, h); + } + +#if (LV_COLOR_16_SWAP != 0) + lcd.pushImageDMA(area->x1, area->y1, w, h,(lgfx::rgb565_t*)&color_p->full); +#else + lcd.pushImageDMA(area->x1, area->y1, w, h,(lgfx::rgb565_t*)&color_p->full); +#endif + + lv_disp_flush_ready(disp); +} + +void my_touchpad_read(lv_indev_drv_t * indev_driver, lv_indev_data_t * data) +{ + // Serialize Wire access with SenseCapHAL (TCA9535 radio expander). + // g_i2c_mutex is nullptr until radio_init() creates it — safe to skip then. + // Must check the return value: if we don't hold the mutex, skip getTouch() + // entirely to avoid racing with TCA9535 I2C transactions and corrupting the bus. + bool have_mutex = !g_i2c_mutex || (xSemaphoreTake(g_i2c_mutex, portMAX_DELAY) == pdTRUE); + + uint16_t x, y; + bool touched = have_mutex && lcd.getTouch(&x, &y); + + if (have_mutex && g_i2c_mutex) xSemaphoreGive(g_i2c_mutex); + + if (touched) + { + data->state = LV_INDEV_STATE_PR; + data->point.x = x; + data->point.y = y; + } + else + { + data->state = LV_INDEV_STATE_REL; + } +} + +// void my_touchpad_read(lv_indev_drv_t *indev_driver, lv_indev_data_t *data) +// { +// if (touch_has_signal()) +// { +// if (touch_touched()) +// { +// data->state = LV_INDEV_STATE_PR; + +// /*Set the coordinates*/ +// data->point.x = touch_last_x; +// data->point.y = touch_last_y; +// // #ifndef MODE_RELEASE +// // Serial.printf("Data x: %d, Data y: %d", touch_last_x, touch_last_y); +// // Serial.println(); +// // #endif +// } +// else if (touch_released()) +// { +// data->state = LV_INDEV_STATE_REL; +// } +// } +// else +// { +// data->state = LV_INDEV_STATE_REL; +// } +// delay(15); +// } + +void initializeUI() { + + Serial.println("initialize UI..."); + + /* + #ifdef ENABLE_STARTUP_LOGO + lv_disp_load_scr(ui_ScreenLogo); + for( int i=0; i < 100; i++ ){ + lv_task_handler(); + delay(10); + } + lv_scr_load_anim(ui_Screen1, LV_SCR_LOAD_ANIM_MOVE_TOP, 500, 0, true); + #else + ui_init(); + #endif + */ + uiManager = new UIManager(); + uiManager->setNightMode(false); +} + +void createSemaphores() { + semaphoreData = xSemaphoreCreateMutex(); + xSemaphoreGive(semaphoreData); +} + +// Believe it or not, this std C function is busted on some platforms! +static uint32_t _atoi(const char* sp) { + uint32_t n = 0; + while (*sp && *sp >= '0' && *sp <= '9') { + n *= 10; + n += (*sp++ - '0'); + } + return n; +} + +/* -------------------------------------------------------------------------------------- */ + +static void msgstore_dm_path(char* out, size_t len, const uint8_t* pub_key) { + snprintf(out, len, "/m_%02x%02x%02x%02x.log", + pub_key[0], pub_key[1], pub_key[2], pub_key[3]); +} + +static const char* MSGSTORE_PUBLIC_PATH = "/m_public.log"; + +static void msgstore_rotate_if_needed(const char* path) { +#if defined(ESP32) + if (!SPIFFS.exists(path)) return; + File f = SPIFFS.open(path, "r"); + if (!f) return; + size_t sz = f.size(); + f.close(); + if (sz > MSGSTORE_MAX_BYTES) SPIFFS.remove(path); +#endif +} + +void msgstore_append_dm(const uint8_t* pub_key, uint32_t ts, bool sent, const char* text) { +#if defined(ESP32) + char path[24]; + msgstore_dm_path(path, sizeof(path), pub_key); + msgstore_rotate_if_needed(path); + File f = SPIFFS.open(path, FILE_APPEND); + if (!f) return; + f.printf("%u|%c|%s\n", (unsigned)ts, sent ? '>' : '<', text ? text : ""); + f.close(); +#endif +} + +void msgstore_append_public(uint32_t ts, const char* sender, bool sent, const char* text) { +#if defined(ESP32) + msgstore_rotate_if_needed(MSGSTORE_PUBLIC_PATH); + File f = SPIFFS.open(MSGSTORE_PUBLIC_PATH, FILE_APPEND); + if (!f) return; + f.printf("%u|%s|%c|%s\n", (unsigned)ts, + sender ? sender : "?", sent ? '>' : '<', text ? text : ""); + f.close(); +#endif +} + +// Returns true if a DM file line is valid; fills ts, dir, text. +static bool parse_dm_line(const String& line, uint32_t& ts, char& dir, String& text) { + int p1 = line.indexOf('|'); + int p2 = line.indexOf('|', p1 + 1); + if (p1 < 1 || p2 < p1 + 2) return false; + ts = (uint32_t) line.substring(0, p1).toInt(); + if (ts == 0) return false; + dir = line.charAt(p1 + 1); + if (dir != '>' && dir != '<') return false; + text = line.substring(p2 + 1); + text.trim(); + return text.length() > 0; +} + +void msgstore_load_dm(const uint8_t* pub_key) { +#if defined(ESP32) + // LVGL heap is 48 KB, shared with all UI widgets. Each bubble needs ~4 LVGL + // objects (~600 B). Limit history to the last 20 messages to avoid OOM. + static const int MAX_DISPLAY = 20; + + char path[24]; + msgstore_dm_path(path, sizeof(path), pub_key); + if (!SPIFFS.exists(path)) return; + + // Pass 1 — count valid lines so we know how many to skip + File f = SPIFFS.open(path, "r"); + if (!f) return; + int total = 0; + while (f.available()) { + String line = f.readStringUntil('\n'); + uint32_t ts; char dir; String text; + if (parse_dm_line(line, ts, dir, text)) total++; + } + f.close(); + + // Pass 2 — skip oldest, render only the last MAX_DISPLAY valid entries + f = SPIFFS.open(path, "r"); + if (!f) return; + int skip = (total > MAX_DISPLAY) ? total - MAX_DISPLAY : 0; + int seen = 0; + while (f.available()) { + String line = f.readStringUntil('\n'); + uint32_t ts; char dir; String text; + if (!parse_dm_line(line, ts, dir, text)) continue; + if (seen++ < skip) continue; + char time_buf[16]; + format_time(ts, time_buf, sizeof(time_buf)); + uiManager->addPrivateChatBubble(time_buf, text.c_str(), dir == '>', false); + } + f.close(); + // scroll is done by the caller (handleContactClick) after flex layout is re-enabled +#endif +} + +void msgstore_load_public() { +#if defined(ESP32) + static const int MAX_DISPLAY = 20; + + if (!SPIFFS.exists(MSGSTORE_PUBLIC_PATH)) return; + + // Pass 1 — count valid lines + File f = SPIFFS.open(MSGSTORE_PUBLIC_PATH, "r"); + if (!f) return; + int total = 0; + while (f.available()) { + String line = f.readStringUntil('\n'); + int p1 = line.indexOf('|'); + int p2 = line.indexOf('|', p1 + 1); + int p3 = line.indexOf('|', p2 + 1); + if (p1 < 1 || p2 < p1 + 2 || p3 < p2 + 2) continue; + if ((uint32_t)line.substring(0, p1).toInt() == 0) continue; + char dir = line.charAt(p2 + 1); + if (dir != '>' && dir != '<') continue; + String text = line.substring(p3 + 1); text.trim(); + if (text.length() == 0) continue; + total++; + } + f.close(); + + // Pass 2 — skip oldest, render last MAX_DISPLAY + f = SPIFFS.open(MSGSTORE_PUBLIC_PATH, "r"); + if (!f) return; + int skip = (total > MAX_DISPLAY) ? total - MAX_DISPLAY : 0; + int seen = 0; + while (f.available()) { + String line = f.readStringUntil('\n'); + int p1 = line.indexOf('|'); + int p2 = line.indexOf('|', p1 + 1); + int p3 = line.indexOf('|', p2 + 1); + if (p1 < 1 || p2 < p1 + 2 || p3 < p2 + 2) continue; + uint32_t ts = (uint32_t)line.substring(0, p1).toInt(); + if (ts == 0) continue; + String sender = line.substring(p1 + 1, p2); + char dir = line.charAt(p2 + 1); + if (dir != '>' && dir != '<') continue; + String text = line.substring(p3 + 1); text.trim(); + if (text.length() == 0) continue; + if (seen++ < skip) continue; + char time_buf[16]; + format_time(ts, time_buf, sizeof(time_buf)); + uiManager->addChatBubble(time_buf, sender.c_str(), text.c_str(), dir == '>', false); + } + f.close(); + // scroll done by caller after endPublicHistoryLoad() re-enables flex +#endif +} + +/* -------------------------------------------------------------------------------------- */ + +struct NodePrefs { // persisted to file + float airtime_factor; + char node_name[32]; + double node_lat, node_lon; + float freq; + uint8_t tx_power_dbm; + uint8_t sf; // was unused[0] + uint8_t cr; // was unused[1] + uint8_t _pad; // was unused[2] + float bw; // new field (zeros from old 60-byte files → defaults applied in begin()) +}; + +#ifndef FIRMWARE_BUILD_DATE + #define FIRMWARE_BUILD_DATE "19 Apr 2026" +#endif + +#ifndef FIRMWARE_VERSION + #define FIRMWARE_VERSION "v1.15.0" +#endif + +#define FIRMWARE_ROLE "Chat" + +class MyMesh : public BaseChatMesh, ContactVisitor { + FILESYSTEM* _fs; + NodePrefs _prefs; + uint32_t expected_ack_crc; + ChannelDetails* _public; + unsigned long last_msg_sent; + ContactInfo* curr_recipient; + char command[512+10]; + uint8_t tmp_buf[256]; + char hex_buf[512]; + + const char* getTypeName(uint8_t type) const { + if (type == ADV_TYPE_CHAT) return "Chat"; + if (type == ADV_TYPE_REPEATER) return "Repeater"; + if (type == ADV_TYPE_ROOM) return "Room"; + return "??"; // unknown + } + + void loadContacts() { + if (_fs->exists("/contacts")) { + #if defined(RP2040_PLATFORM) + File file = _fs->open("/contacts", "r"); + #else + File file = _fs->open("/contacts"); + #endif + if (file) { + bool full = false; + while (!full) { + ContactInfo c; + uint8_t pub_key[32]; + uint8_t unused; + + bool success = (file.read(pub_key, 32) == 32); + success = success && (file.read((uint8_t *) &c.name, 32) == 32); + success = success && (file.read(&c.type, 1) == 1); + success = success && (file.read(&c.flags, 1) == 1); + success = success && (file.read(&unused, 1) == 1); + success = success && (file.read((uint8_t *) &c.lastmod, 4) == 4); + success = success && (file.read((uint8_t *) &c.out_path_len, 1) == 1); + success = success && (file.read((uint8_t *) &c.last_advert_timestamp, 4) == 4); + success = success && (file.read(c.out_path, 64) == 64); + c.gps_lat = c.gps_lon = 0; // not yet supported + + if (!success) break; // EOF + + c.id = mesh::Identity(pub_key); + uiManager->addContactToUI(c); + if (!addContact(c)) full = true; + } + file.close(); + } + } + } + + void saveContacts() { +#if defined(NRF52_PLATFORM) + _fs->remove("/contacts"); + File file = _fs->open("/contacts", FILE_O_WRITE); +#elif defined(RP2040_PLATFORM) + File file = _fs->open("/contacts", "w"); +#else + File file = _fs->open("/contacts", "w", true); +#endif + if (file) { + ContactsIterator iter; + ContactInfo c; + uint8_t unused = 0; + + while (iter.hasNext(this, c)) { + bool success = (file.write(c.id.pub_key, 32) == 32); + success = success && (file.write((uint8_t *) &c.name, 32) == 32); + success = success && (file.write(&c.type, 1) == 1); + success = success && (file.write(&c.flags, 1) == 1); + success = success && (file.write(&unused, 1) == 1); + success = success && (file.write((uint8_t *) &c.lastmod, 4) == 4); + success = success && (file.write((uint8_t *) &c.out_path_len, 1) == 1); + success = success && (file.write((uint8_t *) &c.last_advert_timestamp, 4) == 4); + success = success && (file.write(c.out_path, 64) == 64); + + if (!success) break; // write failed + } + file.close(); + } + } + + void setClock(uint32_t timestamp) { + getRTCClock()->setCurrentTime(timestamp); + struct timeval tv = { .tv_sec = (time_t)timestamp, .tv_usec = 0 }; + settimeofday(&tv, nullptr); + g_clock_synced = true; + Serial.println(" (OK - clock set!)"); + if (uiManager) { + time_t ts = (time_t)timestamp; + struct tm t; + localtime_r(&ts, &t); + uiManager->updateDateTime(t); + } + } + + void importCard(const char* command) { + while (*command == ' ') command++; // skip leading spaces + if (memcmp(command, "meshcore://", 11) == 0) { + command += 11; // skip the prefix + char *ep = strchr(command, 0); // find end of string + while (ep > command) { + ep--; + if (mesh::Utils::isHexChar(*ep)) break; // found tail end of card + *ep = 0; // remove trailing spaces and other junk + } + int len = strlen(command); + if (len % 2 == 0) { + len >>= 1; // halve, for num bytes + if (mesh::Utils::fromHex(tmp_buf, len, command)) { + importContact(tmp_buf, len); + return; + } + } + } + Serial.println(" error: invalid format"); + } + +protected: + float getAirtimeBudgetFactor() const override { + return _prefs.airtime_factor; + } + + int calcRxDelay(float score, uint32_t air_time) const override { + return 0; // disable rxdelay + } + + bool allowPacketForward(const mesh::Packet* packet) override { + return true; + } + + void onDiscoveredContact(ContactInfo& contact, bool is_new, uint8_t path_len, const uint8_t* path) override { + Serial.printf("ADVERT from -> %s\n", contact.name); + Serial.printf(" type: %s\n", getTypeName(contact.type)); + Serial.print(" public key: "); mesh::Utils::printHex(Serial, contact.id.pub_key, PUB_KEY_SIZE); Serial.println(); + + if (is_new) { + uiManager->addContactToUI(contact); + } else { + uiManager->updateContactLastSeen(contact.id.pub_key, contact.lastmod); + } + saveContacts(); + } + + void onContactPathUpdated(const ContactInfo& contact) override { + Serial.printf("PATH to: %s, path_len=%d\n", contact.name, (int32_t) contact.out_path_len); + saveContacts(); + } + + ContactInfo* processAck(const uint8_t *data) override { + if (memcmp(data, &expected_ack_crc, 4) == 0) { // got an ACK from recipient + Serial.printf(" Got ACK! (round trip: %d millis)\n", _ms->getMillis() - last_msg_sent); + // NOTE: the same ACK can be received multiple times! + expected_ack_crc = 0; // reset our expected hash, now that we have received ACK + if (uiManager) uiManager->setSendStatus(1); + return NULL; // TODO: really should return ContactInfo pointer + } + + //uint32_t crc; + //memcpy(&crc, data, 4); + //MESH_DEBUG_PRINTLN("unknown ACK received: %08X (expected: %08X)", crc, expected_ack_crc); + return NULL; + } + + void onMessageRecv(const ContactInfo& from, mesh::Packet* pkt, uint32_t sender_timestamp, const char *text) override { + Serial.printf("(%s) MSG -> from %s\n", pkt->isRouteDirect() ? "DIRECT" : "FLOOD", from.name); + Serial.printf(" %s\n", text); + + setClock(sender_timestamp); + + if (strcmp(text, "clock sync") == 0) { // special text command + setClock(sender_timestamp + 1); + } + + char time_buf[16]; + format_time(sender_timestamp, time_buf, sizeof(time_buf)); + + uiManager->routeIncomingDM(from.id.pub_key, from.name, time_buf, text); + msgstore_append_dm(from.id.pub_key, sender_timestamp, false, text); + } + + void onCommandDataRecv(const ContactInfo& from, mesh::Packet* pkt, uint32_t sender_timestamp, const char *text) override { + MESH_DEBUG_PRINTLN("onCommandDataRecv"); + } + void onSignedMessageRecv(const ContactInfo& from, mesh::Packet* pkt, uint32_t sender_timestamp, const uint8_t *sender_prefix, const char *text) override { + MESH_DEBUG_PRINTLN("onSignedMessageRecv"); + } + + void onChannelMessageRecv(const mesh::GroupChannel& channel, mesh::Packet* pkt, uint32_t timestamp, const char *text) override { + if (pkt->isRouteDirect()) { + Serial.printf("PUBLIC CHANNEL MSG -> (Direct!)\n"); + } else { + Serial.printf("PUBLIC CHANNEL MSG -> (Flood) hops %d\n", pkt->path_len); + } + Serial.printf(" %s\n", text); + + setClock(timestamp); + + // Only public? + // if (strcmp(channel.secret, PUBLIC_GROUP_PSK) != 0) + // return; + + if (pkt->getPayloadType() != PAYLOAD_TYPE_GRP_TXT) + return; + + char time_buf[16]; + format_time(timestamp, time_buf, sizeof(time_buf)); + + char sender[32]; + char msg[192]; + + parse_group_message(text, sender, sizeof(sender), msg, sizeof(msg)); + + bool is_self = (strcmp(sender, _prefs.node_name) == 0); + + uiManager->addChatBubble(time_buf, sender, msg, is_self); + msgstore_append_public(timestamp, sender, is_self, msg); + } + + uint8_t onContactRequest(const ContactInfo& contact, uint32_t sender_timestamp, const uint8_t* data, uint8_t len, uint8_t* reply) override { + MESH_DEBUG_PRINTLN("onContactRequest"); + // TODO: Return telemetry data + return 0; // unknown + } + + void onContactResponse(const ContactInfo& contact, const uint8_t* data, uint8_t len) override { + MESH_DEBUG_PRINTLN("onContactResponse"); + // not supported + } + + uint32_t calcFloodTimeoutMillisFor(uint32_t pkt_airtime_millis) const override { + return SEND_TIMEOUT_BASE_MILLIS + (FLOOD_SEND_TIMEOUT_FACTOR * pkt_airtime_millis); + } + uint32_t calcDirectTimeoutMillisFor(uint32_t pkt_airtime_millis, uint8_t path_len) const override { + return SEND_TIMEOUT_BASE_MILLIS + + ( (pkt_airtime_millis*DIRECT_SEND_PERHOP_FACTOR + DIRECT_SEND_PERHOP_EXTRA_MILLIS) * (path_len + 1)); + } + + void onSendTimeout() override { + Serial.println(" ERROR: timed out, no ACK."); + if (uiManager) uiManager->setSendStatus(2); + } + +public: + MyMesh(mesh::Radio& radio, StdRNG& rng, mesh::RTCClock& rtc, SimpleMeshTables& tables) + : BaseChatMesh(radio, *new ArduinoMillis(), rng, rtc, *new StaticPoolPacketManager(16), tables) + { + // defaults + memset(&_prefs, 0, sizeof(_prefs)); + _prefs.airtime_factor = 2.0; // one third + #ifdef ADVERT_NAME + strcpy(_prefs.node_name, ADVERT_NAME); + #else + strcpy(_prefs.node_name, "NONAME"); + #endif + _prefs.freq = LORA_FREQ; + _prefs.tx_power_dbm = LORA_TX_POWER; + _prefs.bw = LORA_BW; + _prefs.sf = LORA_SF; + _prefs.cr = LORA_CR; + + command[0] = 0; + curr_recipient = NULL; + } + const char* getFirmwareVer() { return FIRMWARE_VERSION; } + const char* getBuildDate() { return FIRMWARE_BUILD_DATE; } + const char* getRole() { return FIRMWARE_ROLE; } + const char* getNodeName() { return _prefs.node_name; } + float getFreqPref() const { return _prefs.freq; } + float getBwPref() const { return _prefs.bw; } + uint8_t getSfPref() const { return _prefs.sf; } + uint8_t getCrPref() const { return _prefs.cr; } + uint8_t getTxPowerPref() const { return _prefs.tx_power_dbm; } + + void begin(FILESYSTEM& fs) { + _fs = &fs; + + BaseChatMesh::begin(); + + #if defined(NRF52_PLATFORM) + IdentityStore store(fs, ""); + #elif defined(RP2040_PLATFORM) + IdentityStore store(fs, "/identity"); + store.begin(); + #else + IdentityStore store(fs, "/identity"); + #endif + if (!store.load("_main", self_id, _prefs.node_name, sizeof(_prefs.node_name))) { // legacy: node_name was from identity file + // Need way to get some entropy to seed RNG + // Serial.println("Press ENTER to generate key:"); + // char c = 0; + // while (c != '\n') { // wait for ENTER to be pressed + // if (Serial.available()) c = Serial.read(); + // } + ((StdRNG *)getRNG())->begin(millis()); + + self_id = mesh::LocalIdentity(getRNG()); // create new random identity + int count = 0; + while (count < 10 && (self_id.pub_key[0] == 0x00 || self_id.pub_key[0] == 0xFF)) { // reserved id hashes + self_id = mesh::LocalIdentity(getRNG()); count++; + } + store.save("_main", self_id); + } + + // load persisted prefs + if (_fs->exists("/node_prefs")) { + #if defined(RP2040_PLATFORM) + File file = _fs->open("/node_prefs", "r"); + #else + File file = _fs->open("/node_prefs"); + #endif + if (file) { + file.read((uint8_t *) &_prefs, sizeof(_prefs)); + file.close(); + } + } + // Apply defaults for fields that were zero in old saved files + if (_prefs.bw == 0.0f) _prefs.bw = LORA_BW; + if (_prefs.sf == 0) _prefs.sf = LORA_SF; + if (_prefs.cr == 0) _prefs.cr = LORA_CR; + + loadContacts(); + _public = addChannel("Public", PUBLIC_GROUP_PSK); // pre-configure Andy's public channel + } + + void savePrefs() { +#if defined(NRF52_PLATFORM) + _fs->remove("/node_prefs"); + File file = _fs->open("/node_prefs", FILE_O_WRITE); +#elif defined(RP2040_PLATFORM) + File file = _fs->open("/node_prefs", "w"); +#else + File file = _fs->open("/node_prefs", "w", true); +#endif + if (file) { + file.write((const uint8_t *)&_prefs, sizeof(_prefs)); + file.close(); + } + } + + void showWelcome() { + Serial.println("===== MeshCore Chat Terminal ====="); + Serial.println(); + Serial.printf("WELCOME %s\n", _prefs.node_name); + mesh::Utils::printHex(Serial, self_id.pub_key, PUB_KEY_SIZE); + Serial.println(); + Serial.println(" (enter 'help' for basic commands)"); + Serial.println(); + } + + void sendSelfAdvert(int delay_millis) { + auto pkt = createSelfAdvert(_prefs.node_name, _prefs.node_lat, _prefs.node_lon); + if (pkt) { + sendFlood(pkt, delay_millis); + } + } + + // ContactVisitor + void onContactVisit(const ContactInfo& contact) override { + Serial.printf(" %s - ", contact.name); + char tmp[40]; + int32_t secs = contact.last_advert_timestamp - getRTCClock()->getCurrentTime(); + AdvertTimeHelper::formatRelativeTimeDiff(tmp, secs, false); + Serial.println(tmp); + } + + void handleCommand(const char* command) { + while (*command == ' ') command++; // skip leading spaces + + if (memcmp(command, "send ", 5) == 0) { + if (curr_recipient) { + const char *text = &command[5]; + uint32_t est_timeout; + + int result = sendMessage(*curr_recipient, getRTCClock()->getCurrentTime(), 0, text, expected_ack_crc, est_timeout); + if (result == MSG_SEND_FAILED) { + Serial.println(" ERROR: unable to send."); + } else { + last_msg_sent = _ms->getMillis(); + Serial.printf(" (message sent - %s)\n", result == MSG_SEND_SENT_FLOOD ? "FLOOD" : "DIRECT"); + } + } else { + Serial.println(" ERROR: no recipient selected (use 'to' cmd)."); + } + } else if (memcmp(command, "public ", 7) == 0) { // send GroupChannel msg + uint8_t temp[5+MAX_TEXT_LEN+32]; + uint32_t timestamp = getRTCClock()->getCurrentTime(); + memcpy(temp, ×tamp, 4); // mostly an extra blob to help make packet_hash unique + temp[4] = 0; // attempt and flags + + sprintf((char *) &temp[5], "%s: %s", _prefs.node_name, &command[7]); // : + temp[5 + MAX_TEXT_LEN] = 0; // truncate if too long + + int len = strlen((char *) &temp[5]); + auto pkt = createGroupDatagram(PAYLOAD_TYPE_GRP_TXT, _public->channel, temp, 5 + len); + if (pkt) { + sendFlood(pkt); + Serial.println(" Sent."); + } else { + Serial.println(" ERROR: unable to send"); + } + } else if (memcmp(command, "list", 4) == 0) { // show Contact list, by most recent + int n = 0; + if (command[4] == ' ') { // optional param, last 'N' + n = atoi(&command[5]); + } + scanRecentContacts(n, this); + } else if (strcmp(command, "clock") == 0) { // show current time + uint32_t now = getRTCClock()->getCurrentTime(); + DateTime dt = DateTime(now); + Serial.printf( "%02d:%02d - %d/%d/%d UTC\n", dt.hour(), dt.minute(), dt.day(), dt.month(), dt.year()); + } else if (memcmp(command, "time ", 5) == 0) { // set time (to epoch seconds) + uint32_t secs = _atoi(&command[5]); + setClock(secs); + } else if (memcmp(command, "to ", 3) == 0) { // set current recipient + curr_recipient = searchContactsByPrefix(&command[3]); + if (curr_recipient) { + Serial.printf(" Recipient %s now selected.\n", curr_recipient->name); + } else { + Serial.println(" Error: Name prefix not found."); + } + } else if (strcmp(command, "to") == 0) { // show current recipient + if (curr_recipient) { + Serial.printf(" Current: %s\n", curr_recipient->name); + } else { + Serial.println(" Err: no recipient selected"); + } + } else if (strcmp(command, "advert") == 0) { + auto pkt = createSelfAdvert(_prefs.node_name, _prefs.node_lat, _prefs.node_lon); + if (pkt) { + sendZeroHop(pkt); + Serial.println(" (advert sent, zero hop)."); + } else { + Serial.println(" ERR: unable to send"); + } + } else if (strcmp(command, "reset path") == 0) { + if (curr_recipient) { + resetPathTo(*curr_recipient); + saveContacts(); + Serial.println(" Done."); + } + } else if (memcmp(command, "card", 4) == 0) { + Serial.printf("Hello %s\n", _prefs.node_name); + auto pkt = createSelfAdvert(_prefs.node_name, _prefs.node_lat, _prefs.node_lon); + if (pkt) { + uint8_t len = pkt->writeTo(tmp_buf); + releasePacket(pkt); // undo the obtainNewPacket() + + mesh::Utils::toHex(hex_buf, tmp_buf, len); + Serial.println("Your MeshCore biz card:"); + Serial.print("meshcore://"); Serial.println(hex_buf); + Serial.println(); + } else { + Serial.println(" Error"); + } + } else if (memcmp(command, "import ", 7) == 0) { + importCard(&command[7]); + } else if (memcmp(command, "set ", 4) == 0) { + const char* config = &command[4]; + if (memcmp(config, "af ", 3) == 0) { + _prefs.airtime_factor = atof(&config[3]); + savePrefs(); + Serial.println(" OK"); + } else if (memcmp(config, "name ", 5) == 0) { + StrHelper::strncpy(_prefs.node_name, &config[5], sizeof(_prefs.node_name)); + savePrefs(); + Serial.println(" OK"); + } else if (memcmp(config, "lat ", 4) == 0) { + _prefs.node_lat = atof(&config[4]); + savePrefs(); + Serial.println(" OK"); + } else if (memcmp(config, "lon ", 4) == 0) { + _prefs.node_lon = atof(&config[4]); + savePrefs(); + Serial.println(" OK"); + } else if (memcmp(config, "tx ", 3) == 0) { + _prefs.tx_power_dbm = atoi(&config[3]); + savePrefs(); + Serial.println(" OK - reboot to apply"); + } else if (memcmp(config, "freq ", 5) == 0) { + _prefs.freq = atof(&config[5]); + savePrefs(); + Serial.println(" OK - reboot to apply"); + } else if (memcmp(config, "bw ", 3) == 0) { + _prefs.bw = atof(&config[3]); + savePrefs(); + Serial.println(" OK - reboot to apply"); + } else if (memcmp(config, "sf ", 3) == 0) { + _prefs.sf = (uint8_t)atoi(&config[3]); + savePrefs(); + Serial.println(" OK - reboot to apply"); + } else if (memcmp(config, "cr ", 3) == 0) { + _prefs.cr = (uint8_t)atoi(&config[3]); + savePrefs(); + Serial.println(" OK - reboot to apply"); + } else { + Serial.printf(" ERROR: unknown config: %s\n", config); + } + } else if (memcmp(command, "ver", 3) == 0) { + Serial.println(FIRMWARE_VER_TEXT); + } else if (memcmp(command, "help", 4) == 0) { + Serial.println("Commands:"); + Serial.println(" set {name|lat|lon|freq|tx|af} {value}"); + Serial.println(" card"); + Serial.println(" import {biz card}"); + Serial.println(" clock"); + Serial.println(" time "); + Serial.println(" list {n}"); + Serial.println(" to "); + Serial.println(" to"); + Serial.println(" send "); + Serial.println(" advert"); + Serial.println(" reset path"); + Serial.println(" public "); + } else { + Serial.print(" ERROR: unknown command: "); Serial.println(command); + } + } + + void loop() { + BaseChatMesh::loop(); + + int len = strlen(command); + while (Serial.available() && len < sizeof(command)-1) { + char c = Serial.read(); + if (c != '\n') { + command[len++] = c; + command[len] = 0; + } + Serial.print(c); + } + if (len == sizeof(command)-1) { // command buffer full + command[sizeof(command)-1] = '\r'; + } + + if (len > 0 && command[len - 1] == '\r') { // received complete line + command[len - 1] = 0; // replace newline with C string null terminator + + handleCommand(command); + command[0] = 0; // reset command buffer + } + } +}; + +StdRNG fast_rng; +SimpleMeshTables tables; +MyMesh the_mesh(radio_driver, fast_rng, rtc_clock, tables); + +void halt() { + while (1) ; +} + +void configureDisplay() { + ESP_LOGI(TAG, "Configuring display..."); + + screenWidth = lcd.width(); + screenHeight = lcd.height(); + + lv_disp_draw_buf_init(&draw_buf, disp_draw_buf, NULL, screenWidth * screenHeight / 10); + + /* Initialize the display */ + lv_disp_drv_init(&disp_drv); + /* Change the following line to your display resolution */ + disp_drv.hor_res = screenWidth; + disp_drv.ver_res = screenHeight; + disp_drv.flush_cb = my_disp_flush; + disp_drv.draw_buf = &draw_buf; + lv_disp_drv_register(&disp_drv); + + /* Initialize the (dummy) input device driver */ + static lv_indev_drv_t indev_drv; + lv_indev_drv_init(&indev_drv); + indev_drv.type = LV_INDEV_TYPE_POINTER; + indev_drv.read_cb = my_touchpad_read; + lv_indev_drv_register(&indev_drv); +#ifdef TFT_BL + pinMode(TFT_BL, OUTPUT); + digitalWrite(TFT_BL, HIGH); +#endif + + lcd.fillScreen(0x000000u); +} + +// ── ROOT CAUSE NOTE ────────────────────────────────────────────────────────── +// Upstream LovyanGFX 1.2.7 does NOT understand the IO_EXPANDER pin encoding +// (only the mverch67 fork does). Our SCIndicatorDisplay.h sets +// cfg.pin_cs = 4 | IO_EXPANDER (= 0x44 = 68) +// During Panel_ST7701_Base::init(), LovyanGFX calls +// lgfx::gpio_lo(pin_cs) // assert CS +// ... send SPI init commands (gamma, voltages, RGB666, sleep-out, etc.) ... +// lgfx::gpio_hi(pin_cs) // deassert CS +// gpio_lo(68) on ESP32-S3 (max GPIO 48) is a silent no-op → CS is NEVER +// actually asserted → all SPI init commands are sent into the void → +// the ST7701 never receives its init sequence. +// +// This worked SOMETIMES because: +// - on soft reboot the ST7701 retained state from the previous boot +// - on cold boot from charged caps it was in some semi-init state +// - on cold boot from discharged caps it stayed in factory state → stripes +// +// FIX: manually assert TCA9535 P0.4 (real LCD CS) LOW before lcd.begin() +// and deassert it HIGH after. CS stays LOW for the entire LovyanGFX init, +// so all SPI commands actually reach the ST7701. The internal gpio_lo/hi +// calls in LovyanGFX become harmless no-ops (they target a non-existent +// GPIO 68, but our manual TCA9535 CS state is preserved). +// ──────────────────────────────────────────────────────────────────────────── + +static void sensecap_lcd_cs_assert() { + const uint8_t TCA = 0x20; + // Config Port 0: bit 4 (LCD CS) = OUTPUT, bit 5 (LCD RESX) = OUTPUT, + // others = INPUT. 0xCF = 1100 1111 (bits 4,5 cleared = output). + Wire.beginTransmission(TCA); + Wire.write(0x06); // CONFIG_P0 + Wire.write(0xCF); + uint8_t e1 = Wire.endTransmission(); + + // Output Port 0: bit 4 LOW (CS asserted), bit 5 HIGH (RESX deasserted), + // all other latches HIGH. 0xEF = 1110 1111. + Wire.beginTransmission(TCA); + Wire.write(0x02); // OUTPUT_P0 + Wire.write(0xEF); + uint8_t e2 = Wire.endTransmission(); + + Serial.printf("[lcd_cs] assert LOW: cfg_err=%u out_err=%u\n", e1, e2); +} + +static void sensecap_lcd_cs_deassert() { + const uint8_t TCA = 0x20; + // Output Port 0: all HIGH (CS deasserted, RESX deasserted). + Wire.beginTransmission(TCA); + Wire.write(0x02); // OUTPUT_P0 + Wire.write(0xFF); + uint8_t e = Wire.endTransmission(); + Serial.printf("[lcd_cs] deassert HIGH: out_err=%u\n", e); +} + +void initializeDisplay() { + ESP_LOGI(TAG, "Initializing display..."); + + // Hold the LCD CS LOW manually for the entire lcd.begin() duration so the + // ST7701 actually receives the SPI init sequence. See ROOT CAUSE NOTE above. + sensecap_lcd_cs_assert(); + delay(5); + + bool ok = lcd.begin(); + Serial.printf("[display] lcd.begin() = %s w=%d h=%d\n", ok ? "OK" : "FAIL", lcd.width(), lcd.height()); + + // Release LCD CS now that the SPI init sequence is complete. Subsequent + // RGB pixel data goes via the parallel bus and does not need CS. + sensecap_lcd_cs_deassert(); + + lcd.setBrightness(255); + // Fallback: force GPIO 45 HIGH in case LovyanGFX Light_PWM LEDC setup failed. + pinMode(45, OUTPUT); + digitalWrite(45, HIGH); + Serial.printf("[display] BL GPIO45 after force HIGH: %d\n", digitalRead(45)); + lcd.setTextSize(2); + lcd.setRotation(0); +} + +void initializeTouchScreen() { + ESP_LOGI(TAG, "Initializing touch screen..."); + touch_init(); +} + +void initializeLVGL() { + ESP_LOGI(TAG, "Initializing LVGL..."); + lv_init(); +} + +void initializeMesh() { + Serial.println("[mesh] board.begin()"); + board.begin(); + +#ifndef DISABLE_LORA_FOR_DISPLAY_TEST + Serial.println("[mesh] radio_init()..."); + if (!radio_init()) { + Serial.println("[mesh] FATAL: radio_init() failed - halting"); + halt(); + } + + fast_rng.begin(radio_get_rng_seed()); +#else + Serial.println("[mesh] *** LORA DISABLED FOR DISPLAY TEST ***"); + fast_rng.begin(42); +#endif + + Serial.println("[mesh] SPIFFS.begin()"); +#if defined(NRF52_PLATFORM) + InternalFS.begin(); + the_mesh.begin(InternalFS); +#elif defined(RP2040_PLATFORM) + LittleFS.begin(); + the_mesh.begin(LittleFS); +#elif defined(ESP32) + SPIFFS.begin(true); + the_mesh.begin(SPIFFS); +#else + #error "need to define filesystem" +#endif + Serial.println("[mesh] the_mesh.begin() done"); + + float freq = the_mesh.getFreqPref(); + float bw = the_mesh.getBwPref(); + uint8_t sf = the_mesh.getSfPref(); + uint8_t cr = the_mesh.getCrPref(); + // Always use the build-defined TX power; saved prefs may contain a stale + // value from a previous firmware version with a different default. + uint8_t txpwr = LORA_TX_POWER; + Serial.printf("[mesh] Radio params: freq=%.3f MHz BW=%.1f SF=%d CR=%d TX=%d dBm\n", + freq, bw, (int)sf, (int)cr, (int)txpwr); + radio_set_params(freq, bw, sf, cr); + radio_set_tx_power(txpwr); + + the_mesh.showWelcome(); + + uiManager->populateSettings(the_mesh.getNodeName(), + the_mesh.getFreqPref(), + the_mesh.getBwPref(), + the_mesh.getSfPref(), + the_mesh.getCrPref(), + the_mesh.getTxPowerPref(), + the_mesh.getFirmwareVer(), + the_mesh.getBuildDate()); + + char pk_hex[17]; + mesh::Utils::toHex(pk_hex, the_mesh.self_id.pub_key, 8); + pk_hex[16] = 0; + uiManager->populateHome(the_mesh.getNodeName(), + pk_hex, + the_mesh.getNumContacts(), + the_mesh.getFreqPref()); + uiManager->setMyNodeName(the_mesh.getNodeName()); + + uiManager->beginPublicHistoryLoad(); + msgstore_load_public(); + uiManager->endPublicHistoryLoad(); + uiManager->scrollPublicChatToBottom(); // after flex layout is recalculated + + Serial.printf("[ui] free heap: %u B free PSRAM: %u B\n", + esp_get_free_heap_size(), esp_get_free_internal_heap_size()); + + Serial.println("[mesh] Sending self-advert..."); + the_mesh.sendSelfAdvert(1200); + Serial.println("[mesh] Advert queued (1200ms delay)"); +} + +void setup() { + Serial.begin(115200); + + // Greece: UTC+2 standard (EET), UTC+3 summer (EEST) + // Change this string to match your timezone if needed. + setenv("TZ", "EET-2EEST,M3.5.0/3,M10.5.0/4", 1); + tzset(); + +#ifdef PIN_USER_BTN + pinMode(PIN_USER_BTN, INPUT_PULLUP); +#endif + +#if defined(PIN_BOARD_SDA) && defined(PIN_BOARD_SCL) + // Initialise I2C early so both the touch controller (FT5x06 @ 0x48) + // and the IO expander (TCA9535 @ 0x20) are ready before lcd.begin(). + Wire.begin(PIN_BOARD_SDA, PIN_BOARD_SCL, 400000); +#endif + + initializeDisplay(); + delay(200); + + initializeLVGL(); + initializeTouchScreen(); + configureDisplay(); + + initializeUI(); + + createTasks(); + + // ── Let LVGL render the initial UI before suspending ─────────────────────── + // configureDisplay() fills the RGB framebuffer with black. LVGL needs at + // least one lv_timer_handler() cycle to paint the initial screen into that + // framebuffer. Since lvgl_task (Core 0) runs in parallel with setup() + // (Core 1), a short delay here gives it time to complete the first render, + // so the display shows the UI rather than a blank screen during radio init. + delay(100); + + // ── Suspend LVGL task before radio init ──────────────────────────────────── + // radio_init() calls Wire.end()/Wire.begin() while the LVGL touch callback + // (my_touchpad_read) also accesses Wire. Suspending lvgl_task eliminates + // the race; the I2C mutex (g_i2c_mutex) guards all Wire access once it is + // created inside radio_init(). + Serial.println("[setup] Suspending LVGL task for radio init..."); + vTaskSuspend(t_core0_lvgl); + + initializeMesh(); + + // Mark entire LVGL screen dirty so the first lv_timer_handler() tick + // after resume flushes the full UI. + lv_obj_invalidate(lv_scr_act()); + + Serial.println("[setup] Resuming LVGL task..."); + vTaskResume(t_core0_lvgl); + + vTaskResume(t_core1_core); + + Serial.println("Setup completed"); + + Serial.print("MeshCore "); + Serial.println(the_mesh.getFirmwareVer()); + Serial.print("Build date: "); + Serial.println(the_mesh.getBuildDate()); +} + +void handleCommand(char *msg) +{ + Serial.println("Outgoing data:"); + Serial.println(msg); + the_mesh.handleCommand(msg); +} + +void core_task(void *pvParameters) { + + vTaskSuspend(NULL); + + Serial.printf("[core_task] Mesh loop started on core %d\n", xPortGetCoreID()); + +#ifdef PIN_USER_BTN + bool btn_was_pressed = false; +#endif + + while (1) { + the_mesh.loop(); + rtc_clock.tick(); + +#ifdef PIN_USER_BTN + bool btn_pressed = (digitalRead(PIN_USER_BTN) == LOW); + if (btn_pressed && !btn_was_pressed) { + Serial.println("[btn] Press detected - restarting..."); + delay(50); + ESP.restart(); + } + btn_was_pressed = btn_pressed; +#endif + + vTaskDelay(DELAY_CORE_TASK / portTICK_PERIOD_MS); + } +} + +void loop() { + vTaskDelete(NULL); +} \ No newline at end of file diff --git a/examples/simple_secure_chat_ui/messageStore.h b/examples/simple_secure_chat_ui/messageStore.h new file mode 100644 index 0000000000..ae264fc9b1 --- /dev/null +++ b/examples/simple_secure_chat_ui/messageStore.h @@ -0,0 +1,15 @@ +#pragma once +#include + +// Append-only per-contact / public chat persistence on SPIFFS. +// Each DM contact gets a file keyed by the first 4 bytes of the public key. +// When a file exceeds MSGSTORE_MAX_BYTES it is dropped (oldest history lost). + +#define MSGSTORE_MAX_BYTES 16384 + +void msgstore_append_dm(const uint8_t* pub_key, uint32_t ts, bool sent, const char* text); +void msgstore_append_public(uint32_t ts, const char* sender, bool sent, const char* text); + +// Replays stored history into the UI (calls uiManager->addPrivateChatBubble / addChatBubble). +void msgstore_load_dm(const uint8_t* pub_key); +void msgstore_load_public(); diff --git a/examples/simple_secure_chat_ui/task_clock.cpp b/examples/simple_secure_chat_ui/task_clock.cpp new file mode 100644 index 0000000000..5a3cbbe474 --- /dev/null +++ b/examples/simple_secure_chat_ui/task_clock.cpp @@ -0,0 +1,25 @@ +#include +#include + +#include "esp_log.h" +#include "uiDefines.h" +#include "uiVars.h" + +#define TAG "clock_task" + +void clock_task(void *pvParameters) { + + ESP_LOGI(TAG, "Clock manager: Task running on core %d", xPortGetCoreID()); + + uiManager->clearDateTime(); + + while (1) { + if (g_clock_synced) { + time_t now = time(nullptr); + struct tm t; + localtime_r(&now, &t); + uiManager->updateDateTime(t); + } + vTaskDelay(DELAY_CLOCK_TASK / portTICK_PERIOD_MS); + } +} \ No newline at end of file diff --git a/examples/simple_secure_chat_ui/task_lvgl.cpp b/examples/simple_secure_chat_ui/task_lvgl.cpp new file mode 100644 index 0000000000..d88b6cd38d --- /dev/null +++ b/examples/simple_secure_chat_ui/task_lvgl.cpp @@ -0,0 +1,19 @@ +#include + +#include "esp_log.h" +#include "uiDefines.h" +#include "uiVars.h" + +#define TAG "lvgl_task" + +void lvgl_task(void *pvParameters) { + + vTaskSuspend(NULL); + + ESP_LOGI(TAG, "UI manager: Task running on core %d", xPortGetCoreID()); + + while (1) { + lv_timer_handler(); + vTaskDelay(DELAY_LVGL_TASK / portTICK_PERIOD_MS); + } +} \ No newline at end of file diff --git a/examples/simple_secure_chat_ui/uiManager.cpp b/examples/simple_secure_chat_ui/uiManager.cpp new file mode 100644 index 0000000000..290e4fa9b7 --- /dev/null +++ b/examples/simple_secure_chat_ui/uiManager.cpp @@ -0,0 +1,1656 @@ +#include + +#include "esp_log.h" +#include "uiDefines.h" +#include "uiVars.h" + +#include "uiManager.h" +#include "messageStore.h" + +#include "../src/fonts/fonts.h" + +#include +#include + +#if defined(LANG_GR) +const char *UIManager::days[7] = {"Κυρ", "Δευ", "Τρι", "Τετ", "Πεμ", "Παρ", "Σαβ"}; +const char *UIManager::months[12] = {"Ιαν", "Φεβ", "Μαρ", "Απρ", "Μαι", "Ιουν", + "Ιουλ", "Αυγ", "Σεπ", "Οκτ", "Νοε", "Δεκ"}; +#elif defined(LANG_EN) +const char *UIManager::days[7] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}; +const char *UIManager::months[12] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", + "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}; +#endif + +#define TAG "UIManager" + +extern void handleCommand(char *msg); + +namespace { +struct UIContactInfo { + ContactInfo info; + lv_obj_t* badge = nullptr; + lv_obj_t* badge_label = nullptr; + lv_obj_t* label_lastseen = nullptr; + uint32_t unread = 0; +}; + +UIContactInfo* findContactByPubKey(lv_obj_t* list, const uint8_t* pub_key) { + if (!list) return nullptr; + uint32_t cnt = lv_obj_get_child_cnt(list); + for (uint32_t i = 0; i < cnt; i++) { + lv_obj_t* row = lv_obj_get_child(list, i); + UIContactInfo* uic = (UIContactInfo*) lv_obj_get_user_data(row); + if (uic && memcmp(uic->info.id.pub_key, pub_key, 32) == 0) return uic; + } + return nullptr; +} + +void updateBadge(UIContactInfo* uic) { + if (!uic || !uic->badge || !uic->badge_label) return; + if (uic->unread == 0) { + lv_obj_add_flag(uic->badge, LV_OBJ_FLAG_HIDDEN); + } else { + lv_obj_clear_flag(uic->badge, LV_OBJ_FLAG_HIDDEN); + char buf[8]; + snprintf(buf, sizeof(buf), "%u", (unsigned)uic->unread); + lv_label_set_text(uic->badge_label, buf); + } +} +} // namespace + +UIManager::UIManager() { + + tmp_buf = (char*)malloc(128); + + lv_disp_t * dispp = lv_disp_get_default(); + lv_theme_t * theme = lv_theme_default_init(dispp, lv_palette_main(LV_PALETTE_BLUE), lv_palette_main(LV_PALETTE_RED), + false, LV_FONT_DEFAULT); + lv_disp_set_theme(dispp, theme); + ui_Screen1_screen_init(); + ui____initial_actions0 = lv_obj_create(NULL); + lv_disp_load_scr(ui_Screen1); + +} + +void UIManager::format_time(uint32_t ts, char *buf, size_t len) +{ + time_t t = ts; + struct tm *tm_info = localtime(&t); + strftime(buf, len, "%H:%M:%S", tm_info); +} + +void UIManager::format_datetime(char *buf, size_t size, const struct tm *timeinfo) { + char tmp[64]; + strftime(tmp, sizeof(tmp), "%a, %d %b %Y", timeinfo); + + int wday = timeinfo->tm_wday; // 0=Κυρ ... 6=Σαβ + int mon = timeinfo->tm_mon; // 0=Ιαν ... 11=Δεκ + + // replace %a and %b with selected language + snprintf(buf, size, "%s, %02d %s %d", days[wday], timeinfo->tm_mday, months[mon], 1900 + timeinfo->tm_year); +} + +void UIManager::updateDateTime(const struct tm timeinfo) { + // TODO: Add to settings "Date format" + char date_str[50]; + format_datetime(date_str, sizeof(date_str), &timeinfo); + lv_label_set_text(ui_ValueDate, date_str); + + // TODO: Add to settings "Hour format" + strftime(tmp_buf, 50, "%H:%M", &timeinfo); // 24h format + //strftime(tmp_buf, 50, "%I:%M %p", &timeinfo); // 12h format + lv_label_set_text(ui_ValueTime, tmp_buf); + + // TODO: Add to settings "dim at night" + // TODO: Add to settings "dim hours" + // TODO: Add to settings "dim percentage" + if (timeinfo.tm_hour > 21 || timeinfo.tm_hour < 7) { + setNightMode(true); + } else { + setNightMode(false); + } +} + +void UIManager::clearDateTime() { + #if defined(LANG_EN) + uiManager->updateInfo("Clock sync...", COLOR_WHITE); + #elif defined(LANG_GR) + uiManager->updateInfo("Συγχρονισμός ώρας...", COLOR_WHITE); + #endif + lv_label_set_text(ui_ValueDate, "--- --/--/----"); + lv_label_set_text(ui_ValueTime, "--:--"); +} + +void UIManager::timestampToTime(time_t timestamp, char *buffer, size_t buffer_size) { + struct tm *time_info; + time_info = localtime(×tamp); + strftime(buffer, buffer_size, "%H:%M", time_info); +} + +const char* UIManager::convertDegreesToDirection(int degrees) { + // Normalize degrees to [0, 360) + degrees = degrees % 360; + if (degrees < 0) degrees += 360; + +#if defined(LANG_EN) + static constexpr const char* dirs[] = {"N", "NE", "E", "SE", "S", "SW", "W", "NW"}; +#elif defined(LANG_GR) + static constexpr const char* dirs[] = {"Β", "ΒΑ", "Α", "ΝΑ", "Ν", "ΝΔ", "Δ", "ΒΔ"}; +#else + #error "No Language defined!" +#endif + + // Each direction covers 45°, starting at N = 0° + int index = static_cast((degrees + 22.5) / 45.0) % 8; + return dirs[index]; +} + + +int UIManager::windSpeedToBeaufort(float speed) { + static const float limits[] = { + 0.5, 1.5, 3.3, 5.5, 7.9, 10.7, + 13.8, 17.1, 20.7, 24.4, 28.4, 32.6 + }; + + for (int i = 0; i < 12; ++i) + if (speed < limits[i]) + return i; + return 12; +} + +void UIManager::updateValues() { + lv_label_set_text(ui_ValueTime, "--:--"); +} + +void UIManager::updateInfo(const char *str, uint32_t color) { + // lv_label_set_text(ui_ValueLastUpdate, str); + // lv_obj_set_style_text_color(ui_ValueLastUpdate, lv_color_hex(color), LV_PART_MAIN | LV_STATE_DEFAULT); +} + +void UIManager::addChatBubble(const char *time_str, const char *sender, const char *msg, bool is_self, bool do_scroll) +{ + // Remove oldest + if (chat_count >= MAX_CHAT_MESSAGES) { + lv_obj_del(chat_items[0]); + memmove(&chat_items[0], &chat_items[1], sizeof(lv_obj_t*) * (MAX_CHAT_MESSAGES - 1)); + chat_count--; + } + + // Row container (align bubble left/right) + lv_obj_t *row = lv_obj_create(ui_ChannelMessages); + lv_obj_set_width(row, lv_pct(100)); + lv_obj_set_height(row, LV_SIZE_CONTENT); + lv_obj_set_style_bg_opa(row, 0, 0); + lv_obj_set_style_pad_all(row, 0, 0); + lv_obj_set_style_border_width(row, 0, 0); + lv_obj_set_style_outline_width(row, 0, 0); + lv_obj_clear_flag(row, LV_OBJ_FLAG_SCROLLABLE); + + lv_obj_set_flex_flow(row, LV_FLEX_FLOW_ROW); + lv_obj_set_flex_align(row, + is_self ? LV_FLEX_ALIGN_END : LV_FLEX_ALIGN_START, + LV_FLEX_ALIGN_START, + LV_FLEX_ALIGN_START); + + // Bubble container (COLUMN) + lv_obj_t *bubble = lv_obj_create(row); + lv_obj_set_width(bubble, lv_pct(85)); + lv_obj_set_height(bubble, LV_SIZE_CONTENT); + lv_obj_set_style_radius(bubble, 12, 0); + lv_obj_set_style_pad_all(bubble, 10, 0); + lv_obj_set_style_bg_color(bubble, + is_self ? lv_color_hex(0x1E88E5) : lv_color_hex(0x2C2C2C), 0); + + // Vertical layout inside bubble; cross-align follows bubble side + lv_obj_set_flex_flow(bubble, LV_FLEX_FLOW_COLUMN); + lv_obj_set_flex_align(bubble, + LV_FLEX_ALIGN_START, + is_self ? LV_FLEX_ALIGN_END : LV_FLEX_ALIGN_START, + LV_FLEX_ALIGN_START); + + // Header row (sender + time) + lv_obj_t *hdr = lv_obj_create(bubble); + lv_obj_set_width(hdr, lv_pct(100)); + lv_obj_set_height(hdr, LV_SIZE_CONTENT); + lv_obj_set_style_bg_opa(hdr, 0, 0); + lv_obj_set_style_border_width(hdr, 0, 0); + lv_obj_set_style_pad_all(hdr, 0, 0); + lv_obj_set_style_outline_width(hdr, 0, 0); + + lv_obj_set_flex_flow(hdr, LV_FLEX_FLOW_ROW); + lv_obj_set_flex_align(hdr, + is_self ? LV_FLEX_ALIGN_END : LV_FLEX_ALIGN_START, + LV_FLEX_ALIGN_CENTER, + LV_FLEX_ALIGN_START); + + lv_obj_t *lbl_sender = lv_label_create(hdr); + lv_label_set_text(lbl_sender, sender); + lv_obj_set_style_text_color(lbl_sender, + is_self ? lv_color_hex(0xE3F2FD) : lv_color_hex(0x90CAF9), 0); + lv_obj_set_style_text_font(lbl_sender, &lv_font_arial_22, 0); + + lv_obj_t *lbl_time = lv_label_create(hdr); + lv_label_set_text(lbl_time, time_str); + lv_obj_set_style_text_color(lbl_time, lv_color_hex(0xB0B0B0), 0); + lv_obj_set_style_text_font(lbl_time, &lv_font_arial_20, 0); + + // Message body (below header) + lv_obj_t *lbl_msg = lv_label_create(bubble); + lv_label_set_text(lbl_msg, msg); + lv_label_set_long_mode(lbl_msg, LV_LABEL_LONG_WRAP); + lv_obj_set_width(lbl_msg, lv_pct(100)); + lv_obj_set_style_text_align(lbl_msg, is_self ? LV_TEXT_ALIGN_RIGHT : LV_TEXT_ALIGN_LEFT, 0); + + lv_obj_set_style_text_color(lbl_msg, lv_color_hex(0xFFFFFF), 0); + lv_obj_set_style_text_font(lbl_msg, &lv_font_arial_26, 0); + + // Spacing between header and text + //lv_obj_set_style_margin_top(lbl_msg, 6, 0); + lv_obj_set_style_pad_row(bubble, 6, 0); + + chat_items[chat_count++] = row; + + if (do_scroll) lv_obj_scroll_to_view(row, LV_ANIM_ON); + } + +void UIManager::addPrivateChatBubble(const char *time_str, const char *msg, bool is_self, bool do_scroll) { + + lv_obj_set_style_pad_bottom(ui_ContactMessages, 20, 0); + + // 1. Row container – pushes bubble to the correct side + lv_obj_t* row = LvObj(ui_ContactMessages) + .width(lv_pct(100)) + .height(LV_SIZE_CONTENT) + .bgOpa(0) + .border(0) + .padAll(4) + .scrollable(false) + .flexFlow(LV_FLEX_FLOW_ROW) + .flexAlign( + is_self ? LV_FLEX_ALIGN_END : LV_FLEX_ALIGN_START, // sent=right, received=left + LV_FLEX_ALIGN_START, + LV_FLEX_ALIGN_START + ); + if (!row) { Serial.println("[ui] OOM: addPrivateChatBubble row alloc failed"); return; } + + // 2. Bubble column: message text + timestamp below + lv_obj_t* aligner = LvObj(row) + .width(LV_SIZE_CONTENT) + .height(LV_SIZE_CONTENT) + .bgOpa(0) + .border(0) + .padAll(0) + .scrollable(false) + .flexFlow(LV_FLEX_FLOW_COLUMN) + .flexAlign( + LV_FLEX_ALIGN_START, + is_self ? LV_FLEX_ALIGN_END : LV_FLEX_ALIGN_START, + LV_FLEX_ALIGN_START + ); + lv_obj_set_style_pad_row(aligner, 2, 0); + + // 3. Message bubble label + lv_obj_t *lbl_msg = lv_label_create(aligner); + lv_label_set_long_mode(lbl_msg, LV_LABEL_LONG_WRAP); + lv_label_set_text(lbl_msg, msg); + lv_obj_set_style_text_font(lbl_msg, &lv_font_arial_22, 0); + lv_obj_set_width(lbl_msg, 175); // max width – fits in 310px panel with room to shift + lv_obj_set_height(lbl_msg, LV_SIZE_CONTENT); + lv_obj_set_style_text_align(lbl_msg, is_self ? LV_TEXT_ALIGN_RIGHT : LV_TEXT_ALIGN_LEFT, 0); + lv_obj_set_style_bg_opa(lbl_msg, LV_OPA_COVER, 0); + lv_obj_set_style_radius(lbl_msg, 12, 0); + lv_obj_set_style_pad_all(lbl_msg, 10, 0); + + if (is_self) { + lv_obj_set_style_bg_color(lbl_msg, lv_color_hex(0x1E88E5), 0); + lv_obj_set_style_text_color(lbl_msg, lv_color_hex(0xFFFFFF), 0); + } else { + lv_obj_set_style_bg_color(lbl_msg, lv_color_hex(0x2C2C2C), 0); + lv_obj_set_style_text_color(lbl_msg, lv_color_hex(0xFFFFFF), 0); + } + + // 4. Timestamp below the bubble + lv_obj_t *lbl_time = lv_label_create(aligner); + lv_label_set_text(lbl_time, time_str); + lv_obj_set_style_text_color(lbl_time, lv_color_hex(0x808080), 0); + lv_obj_set_style_text_font(lbl_time, &lv_font_arial_14, 0); + + if (do_scroll) lv_obj_scroll_to_view(row, LV_ANIM_OFF); +} + +void UIManager::scrollPrivateChatToBottom() { + if (ui_ContactMessages) + lv_obj_scroll_to_y(ui_ContactMessages, LV_COORD_MAX, LV_ANIM_OFF); +} + +void UIManager::scrollPublicChatToBottom() { + if (ui_ChannelMessages) + lv_obj_scroll_to_y(ui_ChannelMessages, LV_COORD_MAX, LV_ANIM_OFF); +} + +void UIManager::beginPublicHistoryLoad() { + if (ui_ChannelMessages) lv_obj_set_layout(ui_ChannelMessages, 0); +} + +void UIManager::endPublicHistoryLoad() { + if (ui_ChannelMessages) lv_obj_set_flex_flow(ui_ChannelMessages, LV_FLEX_FLOW_COLUMN); +} + +void UIManager::getInitials(const char *name, char *out) { + out[0] = 0; + if (!name || !name[0]) return; + + const char *p = name; + while (*p && !isalnum((unsigned char)*p)) { + p++; + } + + char first = (*p) ? *p : name[0]; + char second = 0; + const char *space = strchr(name, ' '); + + if (space) { + const char *s = space + 1; + while (*s && !isalnum((unsigned char)*s)) { + s++; + } + if (*s) { + second = *s; + } + } + + out[0] = toupper((unsigned char)first); + if (second) { + out[1] = toupper((unsigned char)second); + out[2] = 0; + } else { + out[1] = 0; + } +} + +void UIManager::formatLastSeen(uint32_t ts, char *out, size_t len) { + if (ts == 0) { + snprintf(out, len, "Never"); + return; + } + + time_t t = (time_t)ts; + struct tm *tm = localtime(&t); + + if (tm == nullptr) { + snprintf(out, len, "Unknown"); + return; + } + + snprintf(out, len, "%02d:%02d %02d/%02d/%02d", + tm->tm_hour, + tm->tm_min, + tm->tm_mday, + tm->tm_mon + 1, + (tm->tm_year + 1900) % 100); // Προσθέτουμε το 1900 και παίρνουμε τα τελευταία 2 ψηφία +} + +static void onContactClick(lv_event_t *e) +{ + UIManager *self = (UIManager*) lv_event_get_user_data(e); + if(self) self->handleContactClick(e); +} + +void UIManager::handleContactClick(lv_event_t *e) +{ + lv_obj_t *row = lv_event_get_target(e); + UIContactInfo *uic = (UIContactInfo*) lv_obj_get_user_data(row); + if (!uic) return; + + ContactInfo* c = &uic->info; + Serial.printf("Clicked: %s\n", c->name); + + strncpy(currentContactName, c->name, sizeof(currentContactName) - 1); + currentContactName[sizeof(currentContactName) - 1] = 0; + memcpy(currentContactPubKey, c->id.pub_key, sizeof(currentContactPubKey)); + hasCurrentContact = true; + + if (ui_ContactName) { + lv_label_set_text(ui_ContactName, currentContactName); + } + + if (ui_ContactMessages) { + lv_obj_clean(ui_ContactMessages); + } + + uic->unread = 0; + updateBadge(uic); + + setSendStatus(-1); + + char cmd[64]; + snprintf(cmd, sizeof(cmd), "to %s", currentContactName); + handleCommand(cmd); + + // Disable flex layout before bulk-loading history messages. + // Without this, each lv_obj_create() child triggers lv_obj_update_layout() + // which recalculates ALL children's positions → O(n²) → watchdog timeout. + // lv_obj_set_flex_flow() below re-enables flex and does ONE O(n) pass. + if (ui_ContactMessages) lv_obj_set_layout(ui_ContactMessages, 0); + + msgstore_load_dm(currentContactPubKey); + + if (ui_ContactMessages) lv_obj_set_flex_flow(ui_ContactMessages, LV_FLEX_FLOW_COLUMN); + scrollPrivateChatToBottom(); // after layout is recalculated +} + +void UIManager::addContactToUI(ContactInfo c) +{ + const int ROW_W = 130; + const int ROW_H = 64; + const int AVATAR = 44; + const int PAD = 4; + + // ============================ + // List row button + // ============================ + lv_obj_t* btn = lv_list_add_btn(ui_Contacts, nullptr, nullptr); + + LvObj(btn, true) + .size(ROW_W, ROW_H) + .padAll(0) + .bgColor(0x000000) + .bgOpa(LV_OPA_COVER) + .noDecor() + .border(1) + .scrollable(false); + + lv_obj_set_layout(btn, 0); + lv_obj_set_style_border_side(btn, LV_BORDER_SIDE_BOTTOM, 0); + lv_obj_set_style_border_color(btn, lv_color_hex(0x222222), 0); + lv_obj_set_style_bg_color(btn, lv_color_hex(0x111111), LV_STATE_PRESSED); + + // Store wrapper (ContactInfo + badge state) + auto* store = new UIContactInfo(); + store->info = c; + lv_obj_set_user_data(btn, store); + + lv_obj_add_event_cb(btn, onContactClick, LV_EVENT_CLICKED, this); + + // ============================ + // Avatar container (hidden when SHOW_CONTACT_AVATAR is not defined) + // ============================ +#ifdef SHOW_CONTACT_AVATAR + lv_obj_t* content = LvObj(btn) + .size(ROW_H, ROW_H) + .position(0, 0) + .padAll(0) + .bgOpa(LV_OPA_TRANSP) + .border(0) + .scrollable(false) + .raw(); + + // Avatar circle + lv_obj_t* avatar = LvObj(content) + .size(AVATAR, AVATAR) + .position(0, 10) + .radius(LV_RADIUS_CIRCLE) + .bgColor(0x4A90E2) + .border(0) + .raw(); + + // Initials + char initials[4]; + if (c.type == ADV_TYPE_REPEATER) { + strcpy(initials, "(R)"); + } else { + getInitials(c.name, initials); + } + + LvLabel(avatar) + .text(initials) + .font(&lv_font_arial_22) + .textColor(0xFFFFFF) + .align(LV_ALIGN_CENTER); +#endif + + // ============================ + // Text column + // ============================ +#ifdef SHOW_CONTACT_AVATAR + int text_x = PAD + AVATAR + PAD; +#else + int text_x = 0; +#endif + int text_w = ROW_W - text_x - PAD; + + lv_obj_t* text_col = LvObj(btn) + .position(text_x, 0) + .size(text_w, ROW_H - PAD) + .padAll(0) + .bgOpa(LV_OPA_TRANSP) + .border(0) + .scrollable(false) + .raw(); + + // Name label + LvLabel(text_col) + .text(c.name) + .position(0, PAD + 4) + .width(text_w) + .font(&lv_font_arial_20) + .textColor(0xFFFFFF) + .wrap(false); + + // Last seen + char lastSeen[32]; + formatLastSeen(c.lastmod, lastSeen, sizeof(lastSeen)); + + lv_obj_t* lbl_ls = LvLabel(text_col) + .text(lastSeen) + .position(0, PAD + 32) + .width(text_w) + .font(&lv_font_arial_16) + .textColor(0x888888) + .wrap(false) + .raw(); + store->label_lastseen = lbl_ls; + + // ============================ + // Unread badge (top-right corner of row) + // ============================ + lv_obj_t* badge = LvObj(btn) + .size(22, 22) + .position(ROW_W - 26, 4) + .radius(LV_RADIUS_CIRCLE) + .bgColor(0xE53935) + .border(0) + .scrollable(false) + .raw(); + lv_obj_add_flag(badge, LV_OBJ_FLAG_HIDDEN); + LvObj(badge, true).clickable(false); + + lv_obj_t* badge_label = LvLabel(badge) + .text("0") + .font(&lv_font_arial_14) + .textColor(0xFFFFFF) + .align(LV_ALIGN_CENTER) + .raw(); + LvObj(badge_label, true).clickable(false); + + store->badge = badge; + store->badge_label = badge_label; + + // ============================ + // Disable child clicks + // ============================ +#ifdef SHOW_CONTACT_AVATAR + LvObj(avatar, true).clickable(false); +#endif + LvObj(text_col, true).clickable(false); +} + +void UIManager::updateContactLastSeen(const uint8_t* pub_key, uint32_t lastmod) +{ + // Called from Core 1 (mesh task). LVGL is NOT thread-safe, so we must NOT + // call any lv_* write functions here. We only update the data field (atomic + // 32-bit write on ESP32). The LVGL timer (Core 0) will refresh the label. + UIContactInfo* uic = findContactByPubKey(ui_Contacts, pub_key); + if (!uic) return; + uic->info.lastmod = lastmod; // atomic on ESP32, safe without mutex +} + +// Called by an LVGL timer on Core 0 — safe to call lv_* here. +void UIManager::refreshLastSeenLabels() +{ + if (!ui_Contacts) return; + uint32_t cnt = lv_obj_get_child_cnt(ui_Contacts); + for (uint32_t i = 0; i < cnt; i++) { + lv_obj_t* row = lv_obj_get_child(ui_Contacts, i); + UIContactInfo* uic = (UIContactInfo*) lv_obj_get_user_data(row); + if (!uic || !uic->label_lastseen) continue; + char buf[32]; + formatLastSeen(uic->info.lastmod, buf, sizeof(buf)); + lv_label_set_text(uic->label_lastseen, buf); + } +} + +void UIManager::onShowKeyboard() +{ + LvKeyboard(ui_Keyboard, true).show(true); + LvObj(ui_DimOverlay, true).clickable(true); + if (activeInput) LvObj(activeInput, true).positionY(channelInputBaseKeybOnY); + if (activeSendBtn) LvObj(activeSendBtn, true).positionY(channelInputBaseKeybOnY); +} + +void UIManager::onHideKeyboard() +{ + LvKeyboard(ui_Keyboard, true).show(false); + LvObj(ui_DimOverlay, true).clickable(false); + if (activeInput) LvObj(activeInput, true).positionY(activeInputBaseY); + if (activeSendBtn) LvObj(activeSendBtn, true).positionY(activeInputBaseY); +} + +static void s_onRestartClick(lv_event_t *e) +{ + ESP.restart(); +} + +static void s_onAdvertiseClick(lv_event_t *e) +{ + UIManager *self = (UIManager*) lv_event_get_user_data(e); + if(self) self->onAdvertiseClick(e); +} + +void UIManager::onAdvertiseClick(lv_event_t* e) +{ + char cmd[16] = "advert"; + handleCommand(cmd); +} + +static void s_onChannelInputFocus(lv_event_t *e) +{ + UIManager *self = (UIManager*) lv_event_get_user_data(e); + if(self) self->onChannelInputFocus(e); +} + +void UIManager::onChannelInputFocus(lv_event_t* e) +{ + lv_obj_t* ta = lv_event_get_target(e); + if(!ui_Keyboard || !ta) return; + + activeInput = ui_ChannelInput; + activeSendBtn = ui_SendBtn; + activeInputBaseY = channelInputBaseY; + + lv_keyboard_set_textarea(ui_Keyboard, ta); + onShowKeyboard(); +} + +static void s_onContactInputFocus(lv_event_t *e) +{ + UIManager *self = (UIManager*) lv_event_get_user_data(e); + if(self) self->onContactInputFocus(e); +} + +void UIManager::onContactInputFocus(lv_event_t* e) +{ + lv_obj_t* ta = lv_event_get_target(e); + if(!ui_Keyboard || !ta) return; + + activeInput = ui_ContactInput; + activeSendBtn = ui_ContactSendBtn; + activeInputBaseY = channelInputBaseY; + + lv_keyboard_set_textarea(ui_Keyboard, ta); + onShowKeyboard(); +} + +static void s_onContactSendClick(lv_event_t *e) +{ + UIManager *self = (UIManager*) lv_event_get_user_data(e); + if(self) self->onContactSendClick(e); +} + +void UIManager::onContactSendClick(lv_event_t* e) +{ + if (!hasCurrentContact) { + Serial.println("[ui] no contact selected — DM ignored"); + return; + } + + const char* msg = lv_textarea_get_text(ui_ContactInput); + if (msg == nullptr || msg[0] == '\0') return; + + char msgCopy[200]; + strncpy(msgCopy, msg, sizeof(msgCopy) - 1); + msgCopy[sizeof(msgCopy) - 1] = 0; + + lv_textarea_set_text(ui_ContactInput, ""); + + char cmd[256]; + snprintf(cmd, sizeof(cmd), "send %s", msgCopy); + handleCommand(cmd); + + char time_buf[16]; + time_t now = time(NULL); + struct tm t; + localtime_r(&now, &t); + snprintf(time_buf, sizeof(time_buf), "%02d:%02d", t.tm_hour, t.tm_min); + + addPrivateChatBubble(time_buf, msgCopy, true); + msgstore_append_dm(currentContactPubKey, (uint32_t)now, true, msgCopy); + + setSendStatus(0); + + onHideKeyboard(); +} + +static void s_onSendClick(lv_event_t *e) +{ + UIManager *self = (UIManager*) lv_event_get_user_data(e); + if(self) self->onSendClick(e); +} + +void UIManager::onSendClick(lv_event_t* e) +{ + char fullMessage[260]; + char msgCopy[200]; + + const char* msg = lv_textarea_get_text(ui_ChannelInput); + if(msg == NULL || msg[0] == '\0') return; + + strncpy(msgCopy, msg, sizeof(msgCopy) - 1); + msgCopy[sizeof(msgCopy) - 1] = '\0'; + + lv_textarea_set_text(ui_ChannelInput, ""); + + snprintf(fullMessage, sizeof(fullMessage), "public %s", msgCopy); + handleCommand(fullMessage); + + char time_buf[16]; + time_t now = time(NULL); + struct tm t; + localtime_r(&now, &t); + + sprintf(time_buf, "%02d:%02d:%02d\n", t.tm_hour, t.tm_min, t.tm_sec); + const char* sender = (myNodeName[0] != 0) ? myNodeName : "Me"; + addChatBubble(time_buf, sender, msgCopy, true); + msgstore_append_public((uint32_t)now, sender, true, msgCopy); + + onHideKeyboard(); +} + +void UIManager::setMyNodeName(const char* name) { + if (!name) { myNodeName[0] = 0; return; } + strncpy(myNodeName, name, sizeof(myNodeName) - 1); + myNodeName[sizeof(myNodeName) - 1] = 0; +} + +void UIManager::routeIncomingDM(const uint8_t* from_pub_key, const char* from_name, + const char* time_str, const char* text) +{ + if (hasCurrentContact && memcmp(from_pub_key, currentContactPubKey, 32) == 0) { + addPrivateChatBubble(time_str, text, false); + return; + } + + UIContactInfo* uic = findContactByPubKey(ui_Contacts, from_pub_key); + if (uic) { + uic->unread++; + updateBadge(uic); + } +} + +void UIManager::setSendStatus(int state) +{ + if (!ui_ContactStatus) return; + + switch (state) { + case 0: + lv_label_set_text(ui_ContactStatus, + #if defined(LANG_GR) + "Αποστολή..."); + #else + "Sending..."); + #endif + lv_obj_set_style_text_color(ui_ContactStatus, lv_color_hex(0xFFC107), 0); + break; + case 1: + lv_label_set_text(ui_ContactStatus, LV_SYMBOL_OK + #if defined(LANG_GR) + " Παραδόθηκε"); + #else + " Delivered"); + #endif + lv_obj_set_style_text_color(ui_ContactStatus, lv_color_hex(0x4CAF50), 0); + break; + case 2: + lv_label_set_text(ui_ContactStatus, LV_SYMBOL_CLOSE + #if defined(LANG_GR) + " Δεν έγινε ack"); + #else + " No ack"); + #endif + lv_obj_set_style_text_color(ui_ContactStatus, lv_color_hex(0xE53935), 0); + break; + default: + lv_label_set_text(ui_ContactStatus, ""); + break; + } +} + +static void s_onSettingsInputFocus(lv_event_t *e) +{ + UIManager *self = (UIManager*) lv_event_get_user_data(e); + if(self) self->onSettingsInputFocus(e); +} + +void UIManager::onSettingsInputFocus(lv_event_t* e) +{ + lv_obj_t* ta = lv_event_get_target(e); + if(!ui_Keyboard || !ta) return; + + // Settings inputs do not slide up — keyboard floats over the form. + activeInput = nullptr; + activeSendBtn = nullptr; + + lv_keyboard_set_textarea(ui_Keyboard, ta); + LvKeyboard(ui_Keyboard, true).show(true); + LvObj(ui_DimOverlay, true).clickable(true); +} + +static void s_onSettingsSaveClick(lv_event_t *e) +{ + UIManager *self = (UIManager*) lv_event_get_user_data(e); + if(self) self->onSettingsSaveClick(e); +} + +static void s_onPresetChange(lv_event_t *e) +{ + UIManager *self = (UIManager*) lv_event_get_user_data(e); + if(self) self->onPresetChange(lv_dropdown_get_selected(lv_event_get_target(e))); +} + +void UIManager::onPresetChange(uint16_t idx) +{ + if (idx == 0) { // Wide band + if (ui_SettingsFreq) lv_textarea_set_text(ui_SettingsFreq, "869.525"); + if (ui_SettingsBw) lv_textarea_set_text(ui_SettingsBw, "250"); + if (ui_SettingsSf) lv_textarea_set_text(ui_SettingsSf, "11"); + if (ui_SettingsCr) lv_textarea_set_text(ui_SettingsCr, "5"); + } else { // Narrow band + if (ui_SettingsFreq) lv_textarea_set_text(ui_SettingsFreq, "869.618"); + if (ui_SettingsBw) lv_textarea_set_text(ui_SettingsBw, "62.5"); + if (ui_SettingsSf) lv_textarea_set_text(ui_SettingsSf, "8"); + if (ui_SettingsCr) lv_textarea_set_text(ui_SettingsCr, "8"); + } +} + +void UIManager::onSettingsSaveClick(lv_event_t* e) +{ + char cmd[96]; + + const char* name = ui_SettingsName ? lv_textarea_get_text(ui_SettingsName) : ""; + const char* freq = ui_SettingsFreq ? lv_textarea_get_text(ui_SettingsFreq) : ""; + const char* bw = ui_SettingsBw ? lv_textarea_get_text(ui_SettingsBw) : ""; + const char* sf = ui_SettingsSf ? lv_textarea_get_text(ui_SettingsSf) : ""; + const char* cr = ui_SettingsCr ? lv_textarea_get_text(ui_SettingsCr) : ""; + const char* tx = ui_SettingsTx ? lv_textarea_get_text(ui_SettingsTx) : ""; + + if (name && name[0]) { + snprintf(cmd, sizeof(cmd), "set name %s", name); + handleCommand(cmd); + } + if (freq && freq[0]) { + snprintf(cmd, sizeof(cmd), "set freq %s", freq); + handleCommand(cmd); + } + if (bw && bw[0]) { + snprintf(cmd, sizeof(cmd), "set bw %s", bw); + handleCommand(cmd); + } + if (sf && sf[0]) { + snprintf(cmd, sizeof(cmd), "set sf %s", sf); + handleCommand(cmd); + } + if (cr && cr[0]) { + snprintf(cmd, sizeof(cmd), "set cr %s", cr); + handleCommand(cmd); + } + if (tx && tx[0]) { + snprintf(cmd, sizeof(cmd), "set tx %s", tx); + handleCommand(cmd); + } + + if (ui_SettingsStatus) { + #if defined(LANG_GR) + lv_label_set_text(ui_SettingsStatus, "Αποθηκεύτηκε. Επανεκκίνηση..."); + #else + lv_label_set_text(ui_SettingsStatus, "Saved. Restarting..."); + #endif + } + + onHideKeyboard(); + + Serial.flush(); + delay(800); + ESP.restart(); +} + +void UIManager::populateSettings(const char* name, float freq, float bw, uint8_t sf, uint8_t cr, + uint8_t tx_power, const char* fw_ver, const char* build_date) +{ + if (ui_SettingsName && name) lv_textarea_set_text(ui_SettingsName, name); + + if (ui_SettingsFreq) { + char buf[16]; + snprintf(buf, sizeof(buf), "%.3f", freq); + lv_textarea_set_text(ui_SettingsFreq, buf); + } + if (ui_SettingsBw) { + char buf[16]; + snprintf(buf, sizeof(buf), "%.1f", bw); + lv_textarea_set_text(ui_SettingsBw, buf); + } + if (ui_SettingsSf) { + char buf[8]; + snprintf(buf, sizeof(buf), "%u", (unsigned)sf); + lv_textarea_set_text(ui_SettingsSf, buf); + } + if (ui_SettingsCr) { + char buf[8]; + snprintf(buf, sizeof(buf), "%u", (unsigned)cr); + lv_textarea_set_text(ui_SettingsCr, buf); + } + if (ui_SettingsTx) { + char buf[8]; + snprintf(buf, sizeof(buf), "%u", (unsigned)tx_power); + lv_textarea_set_text(ui_SettingsTx, buf); + } + if (ui_SettingsFw && fw_ver && build_date) { + char buf[64]; + snprintf(buf, sizeof(buf), "%s (%s)", fw_ver, build_date); + lv_label_set_text(ui_SettingsFw, buf); + } + + // Select the matching preset (does not fire the VALUE_CHANGED event) + if (ui_SettingsPreset) { + bool isNarrow = (fabsf(freq - 869.618f) < 0.01f && bw < 100.0f && sf == 8 && cr == 8); + lv_dropdown_set_selected(ui_SettingsPreset, isNarrow ? 1 : 0); + } +} + +void UIManager::populateHome(const char* name, const char* pub_key_hex, + int contact_count, float freq) +{ + if (ui_HomeNodeName && name) lv_label_set_text(ui_HomeNodeName, name); + if (ui_HomePubKey && pub_key_hex) lv_label_set_text(ui_HomePubKey, pub_key_hex); + + if (ui_HomeInfo) { + char buf[64]; + #if defined(LANG_GR) + snprintf(buf, sizeof(buf), "%.3f MHz · %d επαφές", freq, contact_count); + #else + snprintf(buf, sizeof(buf), "%.3f MHz · %d contacts", freq, contact_count); + #endif + lv_label_set_text(ui_HomeInfo, buf); + } +} + +static void s_onKeyboardEvent(lv_event_t *e) +{ + UIManager *self = (UIManager*) lv_event_get_user_data(e); + if(self) self->onKeyboardEvent(e); +} + +void UIManager::onKeyboardEvent(lv_event_t* e) +{ + lv_event_code_t code = lv_event_get_code(e); + + if(code == LV_EVENT_READY || code == LV_EVENT_CANCEL) + { + LvKeyboard(ui_Keyboard, true).show(false); + + if (activeInput) LvObj(activeInput, true).positionY(activeInputBaseY); + if (activeSendBtn) LvObj(activeSendBtn, true).positionY(activeInputBaseY); + + LvObj(ui_DimOverlay, true) + .bgOpa(0) + .clickable(false); + } +} + + +static void s_onDimOverlayClick(lv_event_t *e) +{ + UIManager *self = (UIManager*) lv_event_get_user_data(e); + if(self) self->onDimOverlayClick(e); +} + +void UIManager::onDimOverlayClick(lv_event_t* e) +{ + onHideKeyboard(); +} + +static void onScrollBeginEvent(lv_event_t *e) +{ + UIManager *self = (UIManager*) lv_event_get_user_data(e); + if(self) self->scroll_begin_event(e); +} + +void UIManager::scroll_begin_event(lv_event_t *e) +{ + if (lv_event_get_code(e) == LV_EVENT_SCROLL_BEGIN) { + lv_anim_t* a = (lv_anim_t*)lv_event_get_param(e); + if (a) a->time = 0; + + } +} + +void UIManager::ui_Screen1_screen_init(void) +{ + //lv_disp_set_rotation(disp, LV_DISP_ROT_90); + //ui_Screen1 = lv_obj_create(NULL); + + ui_Screen1 = LvObj(NULL) + .scrollable(false) + .bgColor(0x000000) + .bgOpa(255); + + LvTabView tabView(ui_Screen1); + tabView + .size(480, 480) + .align(LV_ALIGN_CENTER) + .bgColor(0x000000) + .contentNoScroll() + .tabBtnBg(0x424242) + .tabBtnText(0xFFFFFF, &lv_font_arial_18); + + ui_TabView1 = tabView.raw(); + + #if defined(LANG_EN) + ui_TabPageHome = tabView.addTab("Home"); + ui_TabPageContacts = tabView.addTab("Contacts"); + ui_TabPageChannels = tabView.addTab("Channels"); + ui_TabPageSettings = tabView.addTab("Settings"); + #elif defined(LANG_GR) + ui_TabPageHome = tabView.addTab("Αρχική"); + ui_TabPageContacts = tabView.addTab("Επαφές"); + ui_TabPageChannels = tabView.addTab("Κανάλια"); + ui_TabPageSettings = tabView.addTab("Ρυθμίσεις"); + #endif + + lv_obj_clear_flag(ui_TabPageHome, LV_OBJ_FLAG_SCROLLABLE); + lv_obj_clear_flag(ui_TabPageContacts, LV_OBJ_FLAG_SCROLLABLE); + lv_obj_clear_flag(ui_TabPageChannels, LV_OBJ_FLAG_SCROLLABLE); + + // Node name (large) + ui_HomeNodeName = LvLabel(ui_TabPageHome) + .text("...") + .width(LV_SIZE_CONTENT) + .height(LV_SIZE_CONTENT) + .font(&lv_font_arial_26) + .textColor(0xFFFFFF) + .align(LV_ALIGN_CENTER) + .position(0, -200); + + // Public key (short hex) + ui_HomePubKey = LvLabel(ui_TabPageHome) + .text("") + .width(LV_SIZE_CONTENT) + .height(LV_SIZE_CONTENT) + .font(&lv_font_arial_18) + .textColor(0x888888) + .align(LV_ALIGN_CENTER) + .position(0, -170); + + // Freq + contacts count + ui_HomeInfo = LvLabel(ui_TabPageHome) + .text("") + .width(LV_SIZE_CONTENT) + .height(LV_SIZE_CONTENT) + .font(&lv_font_arial_20) + .textColor(0xAAAAAA) + .align(LV_ALIGN_CENTER) + .position(0, -140); + + ui_ValueDate = LvLabel(ui_TabPageHome) + .text("--- --/--/----") + .width(LV_SIZE_CONTENT) + .height(LV_SIZE_CONTENT) + .font(&lv_font_arial_40) + .textColor(0xFFFFFF) + .opa(255) + .align(LV_ALIGN_CENTER) + .position(0, -85); + + ui_ValueTime = LvLabel(ui_TabPageHome) + .text("--:--") + .width(LV_SIZE_CONTENT) + .height(LV_SIZE_CONTENT) + .font(&lv_font_arial_48) + .textColor(0xFFFFFF) + .opa(255) + .align(LV_ALIGN_CENTER) + .position(0, -25); + + // Advertise button + ui_AdvertiseBtn = LvButton(ui_TabPageHome) + .size(220, 56) + .align(LV_ALIGN_CENTER) + .position(0, 55) + .bgColor(0x1565C0) + .onClick(s_onAdvertiseClick, this) + .raw(); + + lv_obj_t* ui_AdvertiseLabel = LvLabel(ui_AdvertiseBtn) + #if defined(LANG_GR) + .text(LV_SYMBOL_WIFI " Advertise") + #else + .text(LV_SYMBOL_WIFI " Advertise") + #endif + .font(&lv_font_arial_22) + .textColor(0xFFFFFF) + .raw(); + lv_obj_center(ui_AdvertiseLabel); + + lv_obj_t* ui_RestartBtn = LvButton(ui_TabPageHome) + .size(220, 56) + .align(LV_ALIGN_CENTER) + .position(0, 130) + .bgColor(0xC62828) + .onClick(s_onRestartClick, nullptr) + .raw(); + + lv_obj_t* ui_RestartLabel = LvLabel(ui_RestartBtn) + #if defined(LANG_EN) + .text(LV_SYMBOL_REFRESH " Restart") + #elif defined(LANG_GR) + .text(LV_SYMBOL_REFRESH " Επανεκκίνηση") + #endif + .font(&lv_font_arial_22) + .textColor(0xFFFFFF) + .raw(); + lv_obj_center(ui_RestartLabel); + + ui_Contacts = LvList(ui_TabPageContacts) + .width(140) + .height(350) + .align(LV_ALIGN_CENTER) + .position(-155, -25) + .transparent() + .raw(); + + lv_obj_set_style_bg_opa(ui_Contacts, LV_OPA_TRANSP, 0); + lv_obj_set_style_border_width(ui_Contacts, 0, 0); + lv_obj_set_style_outline_width(ui_Contacts, 0, 0); + lv_obj_set_style_shadow_width(ui_Contacts, 0, 0); + //lv_obj_set_scrollbar_mode(ui_Contacts, LV_SCROLLBAR_MODE_OFF); + lv_obj_set_style_bg_opa(ui_Contacts, LV_OPA_TRANSP, LV_PART_ITEMS); + lv_obj_set_style_border_width(ui_Contacts, 0, LV_PART_ITEMS); + lv_obj_set_style_pad_right(ui_Contacts, 8, 0); + + // Vertical divider between contact list and messages panel + LvObj(ui_TabPageContacts) + .size(1, 350) + .align(LV_ALIGN_CENTER) + .position(-80, -25) + .bgColor(0x333333) + .border(0) + .scrollable(false) + .radius(0); + + ui_ContactName = LvLabel(ui_TabPageContacts) + .text("") + .width(300) + .height(LV_SIZE_CONTENT) + .font(&lv_font_arial_22) + .textColor(0xFFFFFF) + .align(LV_ALIGN_CENTER) + .position(80, -195); + + ui_ContactMessages = LvList(ui_TabPageContacts) + .width(310) + .height(290) + .align(LV_ALIGN_CENTER) + .position(80, -40) + .transparent() + .raw(); + + lv_obj_set_style_bg_color(ui_ContactMessages, lv_color_hex(0), 0); + lv_obj_set_style_bg_opa(ui_ContactMessages, LV_OPA_TRANSP, 0); + lv_obj_set_style_border_width(ui_ContactMessages, 0, 0); + lv_obj_set_style_outline_width(ui_ContactMessages, 0, 0); + lv_obj_set_style_shadow_width(ui_ContactMessages, 0, 0); + //lv_obj_set_scrollbar_mode(ui_ContactMessages, LV_SCROLLBAR_MODE_OFF); + lv_obj_set_style_bg_opa(ui_ContactMessages, LV_OPA_TRANSP, LV_PART_ITEMS); + lv_obj_set_style_border_width(ui_ContactMessages, 0, LV_PART_ITEMS); + lv_obj_set_style_pad_right(ui_ContactMessages, 8, 0); + + ui_ContactInput = LvTextArea(ui_TabPageContacts) + .size(371, 40) + .align(LV_ALIGN_CENTER) + .position(-55, channelInputBaseY) + .oneLine(true) + #if defined(LANG_EN) + .placeholder("Write message...") + #elif defined(LANG_GR) + .placeholder("Γράψε μήνυμα...") + #endif + .font(&lv_font_arial_20) + .bgColor(0x111111) + .textColor(0xFFFFFF) + .borderColor(0x444444) + .borderWidth(1) + .radius(6) + .onFocus(s_onContactInputFocus, this) + .raw(); + + ui_ContactSendBtn = LvButton(ui_TabPageContacts) + .size(105, 42) + .align(LV_ALIGN_CENTER) + .position(188, channelInputBaseY) + .bgColor(0x3A7AFE) + .onClick(s_onContactSendClick, this) + .raw(); + + ui_ContactSendLabel = LvLabel(ui_ContactSendBtn) + #if defined(LANG_EN) + .text("Send") + #elif defined(LANG_GR) + .text("Αποστολή") + #endif + .font(&lv_font_arial_18); + lv_obj_center(ui_ContactSendLabel); + + ui_ContactStatus = LvLabel(ui_TabPageContacts) + .text("") + .font(&lv_font_arial_14) + .textColor(0xAAAAAA) + .align(LV_ALIGN_CENTER) + .position(80, channelInputBaseY + 30); + + // LvObj(ui_TabPageContacts) + // .size(2, 400) + // .position(222, 0) + // .bgColor(0x444444) + // .border(0) + // .scrollable(false) + // .radius(0); + + ui_Channels = LvDropdown(ui_TabPageChannels) + .options("Public") + .width(200) + .align(LV_ALIGN_CENTER) + .position(-135, -182) + .clickable(true) + .raw(); + + ui_ChannelMessages = LvList(ui_TabPageChannels) + .width(460) + .height(250) + .align(LV_ALIGN_CENTER) + .transparent() + .padRow(10) + .position(0, -10) + .bgColor(0) + .bgOpa(0) + .border(0) + .noDecor() + .raw(); + + //lv_obj_set_scrollbar_mode(ui_ChannelMessages, LV_SCROLLBAR_MODE_OFF); + lv_obj_set_style_bg_opa(ui_ChannelMessages, LV_OPA_TRANSP, LV_PART_ITEMS); + lv_obj_set_style_border_width(ui_ChannelMessages, 0, LV_PART_ITEMS); + + ui_ChannelDivider = LvObj(ui_TabPageChannels) + .size(460, 1) + .align(LV_ALIGN_CENTER) + .position(0, 150) + .bgColor(0x444444) + .border(0) + .raw(); + + ui_DimOverlay = LvObj(ui_Screen1) + .size(lv_pct(100), lv_pct(100)) + .align(LV_ALIGN_CENTER) + .bgColor(0x000000) + .bgOpa(0) + .bringToFront() + .onClick(s_onDimOverlayClick, this) + .scrollable(false) + .clickable(true) + .raw(); + // Remove only border/padding — do NOT use remove_style_all because it also + // resets width/height (style props in LVGL8) back to 100×100 default, + // which causes the white-square artifact when night mode activates. + lv_obj_set_style_border_width(ui_DimOverlay, 0, 0); + lv_obj_set_style_outline_width(ui_DimOverlay, 0, 0); + lv_obj_set_style_shadow_width(ui_DimOverlay, 0, 0); + lv_obj_set_style_pad_all(ui_DimOverlay, 0, 0); + lv_obj_clear_flag(ui_DimOverlay, LV_OBJ_FLAG_SCROLL_CHAIN_HOR); + lv_obj_clear_flag(ui_DimOverlay, LV_OBJ_FLAG_SCROLL_CHAIN_VER); + + + ui_ChannelInput = LvTextArea(ui_TabPageChannels) + .size(360, 40) + .align(LV_ALIGN_CENTER) + .position(-55, channelInputBaseY) + .oneLine(true) + #if defined(LANG_EN) + .placeholder("Write message...") + #elif defined(LANG_GR) + .placeholder("Γράψε μήνυμα...") + #endif + .font(&lv_font_arial_20) + .bgColor(0x111111) + .textColor(0xFFFFFF) + .borderColor(0x444444) + .borderWidth(1) + .radius(6) + .onFocus(s_onChannelInputFocus, this) + .raw(); + + ui_SendBtn = LvButton(ui_TabPageChannels) + .size(90, 42) + .align(LV_ALIGN_CENTER) + .position(180, channelInputBaseY) + .bgColor(0x3A7AFE) + .onClick(s_onSendClick, this) + .raw(); + + iu_SendLabel = LvLabel(ui_SendBtn) + #if defined(LANG_EN) + .text("Send") + #elif defined(LANG_GR) + .text("Αποστολή") + #endif + .font(&lv_font_arial_18); + lv_obj_center(iu_SendLabel); + + // ---- Settings tab (scrollable, horizontal label+input rows) ---- + lv_obj_add_flag(ui_TabPageSettings, LV_OBJ_FLAG_SCROLLABLE); + lv_obj_set_scrollbar_mode(ui_TabPageSettings, LV_SCROLLBAR_MODE_AUTO); + + // Layout constants: label on left, input on right, same row Y + // Label: width=175, center at x=-115 from tab center → left=40, right=212 + // Input: width=240, center at x=100 from tab center → left=220, right=460 + const lv_coord_t LBL_X = -115; + const lv_coord_t LBL_W = 175; + const lv_coord_t INP_X = 100; + const lv_coord_t INP_W = 240; + const lv_coord_t INP_H = 40; + + lv_coord_t rowY = -195; + + // ---- Row 1: Device name ---- + { + lv_obj_t* lbl = LvLabel(ui_TabPageSettings) + #if defined(LANG_GR) + .text("Όνομα") + #else + .text("Device name") + #endif + .font(&lv_font_arial_20) + .textColor(0xCCCCCC) + .width(LBL_W) + .align(LV_ALIGN_CENTER) + .position(LBL_X, rowY) + .raw(); + lv_obj_set_style_text_align(lbl, LV_TEXT_ALIGN_RIGHT, 0); + + ui_SettingsName = LvTextArea(ui_TabPageSettings) + .size(INP_W, INP_H) + .align(LV_ALIGN_CENTER) + .position(INP_X, rowY) + .oneLine(true) + .font(&lv_font_arial_20) + .bgColor(0x111111) + .textColor(0xFFFFFF) + .borderColor(0x444444) + .borderWidth(1) + .radius(6) + .onFocus(s_onSettingsInputFocus, this) + .raw(); + } + rowY += 50; + + // ---- Row 2: Preset dropdown ---- + { + lv_obj_t* lbl = LvLabel(ui_TabPageSettings) + .text("Preset") + .font(&lv_font_arial_20) + .textColor(0xCCCCCC) + .width(LBL_W) + .align(LV_ALIGN_CENTER) + .position(LBL_X, rowY) + .raw(); + lv_obj_set_style_text_align(lbl, LV_TEXT_ALIGN_RIGHT, 0); + + ui_SettingsPreset = LvDropdown(ui_TabPageSettings) + .options("Wide band\nNarrow band") + .width(INP_W) + .align(LV_ALIGN_CENTER) + .position(INP_X, rowY) + .raw(); + + lv_obj_set_height(ui_SettingsPreset, INP_H); + lv_obj_set_style_bg_color(ui_SettingsPreset, lv_color_hex(0x111111), LV_PART_MAIN); + lv_obj_set_style_text_color(ui_SettingsPreset, lv_color_hex(0xFFFFFF), LV_PART_MAIN); + lv_obj_set_style_border_color(ui_SettingsPreset, lv_color_hex(0x444444), LV_PART_MAIN); + lv_obj_set_style_border_width(ui_SettingsPreset, 1, LV_PART_MAIN); + lv_obj_set_style_text_font(ui_SettingsPreset, &lv_font_arial_20, LV_PART_MAIN); + + lv_obj_t* ddList = lv_dropdown_get_list(ui_SettingsPreset); + if (ddList) { + lv_obj_set_style_bg_color(ddList, lv_color_hex(0x222222), 0); + lv_obj_set_style_text_color(ddList, lv_color_hex(0xFFFFFF), 0); + lv_obj_set_style_text_font(ddList, &lv_font_arial_20, 0); + lv_obj_set_style_border_color(ddList, lv_color_hex(0x444444), 0); + } + lv_obj_add_event_cb(ui_SettingsPreset, s_onPresetChange, LV_EVENT_VALUE_CHANGED, this); + } + rowY += 50; + + // ---- Row 3: Frequency ---- + { + lv_obj_t* lbl = LvLabel(ui_TabPageSettings) + #if defined(LANG_GR) + .text("Συχνότητα (MHz)") + #else + .text("Frequency (MHz)") + #endif + .font(&lv_font_arial_20) + .textColor(0xCCCCCC) + .width(LBL_W) + .align(LV_ALIGN_CENTER) + .position(LBL_X, rowY) + .raw(); + lv_obj_set_style_text_align(lbl, LV_TEXT_ALIGN_RIGHT, 0); + + ui_SettingsFreq = LvTextArea(ui_TabPageSettings) + .size(INP_W, INP_H) + .align(LV_ALIGN_CENTER) + .position(INP_X, rowY) + .oneLine(true) + .font(&lv_font_arial_20) + .bgColor(0x111111) + .textColor(0xFFFFFF) + .borderColor(0x444444) + .borderWidth(1) + .radius(6) + .onFocus(s_onSettingsInputFocus, this) + .raw(); + } + rowY += 50; + + // ---- Row 4: Bandwidth ---- + { + lv_obj_t* lbl = LvLabel(ui_TabPageSettings) + #if defined(LANG_GR) + .text("Bandwidth (kHz)") + #else + .text("Bandwidth (kHz)") + #endif + .font(&lv_font_arial_20) + .textColor(0xCCCCCC) + .width(LBL_W) + .align(LV_ALIGN_CENTER) + .position(LBL_X, rowY) + .raw(); + lv_obj_set_style_text_align(lbl, LV_TEXT_ALIGN_RIGHT, 0); + + ui_SettingsBw = LvTextArea(ui_TabPageSettings) + .size(INP_W, INP_H) + .align(LV_ALIGN_CENTER) + .position(INP_X, rowY) + .oneLine(true) + .font(&lv_font_arial_20) + .bgColor(0x111111) + .textColor(0xFFFFFF) + .borderColor(0x444444) + .borderWidth(1) + .radius(6) + .onFocus(s_onSettingsInputFocus, this) + .raw(); + } + rowY += 50; + + // ---- Row 5: Spreading Factor ---- + { + lv_obj_t* lbl = LvLabel(ui_TabPageSettings) + #if defined(LANG_GR) + .text("Spreading Factor") + #else + .text("Spreading Factor") + #endif + .font(&lv_font_arial_20) + .textColor(0xCCCCCC) + .width(LBL_W) + .align(LV_ALIGN_CENTER) + .position(LBL_X, rowY) + .raw(); + lv_obj_set_style_text_align(lbl, LV_TEXT_ALIGN_RIGHT, 0); + + ui_SettingsSf = LvTextArea(ui_TabPageSettings) + .size(INP_W, INP_H) + .align(LV_ALIGN_CENTER) + .position(INP_X, rowY) + .oneLine(true) + .font(&lv_font_arial_20) + .bgColor(0x111111) + .textColor(0xFFFFFF) + .borderColor(0x444444) + .borderWidth(1) + .radius(6) + .onFocus(s_onSettingsInputFocus, this) + .raw(); + } + rowY += 50; + + // ---- Row 6: Coding Rate ---- + { + lv_obj_t* lbl = LvLabel(ui_TabPageSettings) + #if defined(LANG_GR) + .text("Coding Rate") + #else + .text("Coding Rate") + #endif + .font(&lv_font_arial_20) + .textColor(0xCCCCCC) + .width(LBL_W) + .align(LV_ALIGN_CENTER) + .position(LBL_X, rowY) + .raw(); + lv_obj_set_style_text_align(lbl, LV_TEXT_ALIGN_RIGHT, 0); + + ui_SettingsCr = LvTextArea(ui_TabPageSettings) + .size(INP_W, INP_H) + .align(LV_ALIGN_CENTER) + .position(INP_X, rowY) + .oneLine(true) + .font(&lv_font_arial_20) + .bgColor(0x111111) + .textColor(0xFFFFFF) + .borderColor(0x444444) + .borderWidth(1) + .radius(6) + .onFocus(s_onSettingsInputFocus, this) + .raw(); + } + rowY += 50; + + // ---- Row 7: TX power ---- + { + lv_obj_t* lbl = LvLabel(ui_TabPageSettings) + #if defined(LANG_GR) + .text("Ισχύς (dBm)") + #else + .text("TX power (dBm)") + #endif + .font(&lv_font_arial_20) + .textColor(0xCCCCCC) + .width(LBL_W) + .align(LV_ALIGN_CENTER) + .position(LBL_X, rowY) + .raw(); + lv_obj_set_style_text_align(lbl, LV_TEXT_ALIGN_RIGHT, 0); + + ui_SettingsTx = LvTextArea(ui_TabPageSettings) + .size(INP_W, INP_H) + .align(LV_ALIGN_CENTER) + .position(INP_X, rowY) + .oneLine(true) + .font(&lv_font_arial_20) + .bgColor(0x111111) + .textColor(0xFFFFFF) + .borderColor(0x444444) + .borderWidth(1) + .radius(6) + .onFocus(s_onSettingsInputFocus, this) + .raw(); + } + rowY += 43; + + // Firmware (read-only, centered) + ui_SettingsFw = LvLabel(ui_TabPageSettings) + .text("...") + .font(&lv_font_arial_18) + .textColor(0x888888) + .align(LV_ALIGN_CENTER) + .position(0, rowY); + rowY += 42; + + // Save button + ui_SettingsSaveBtn = LvButton(ui_TabPageSettings) + .size(270, 50) + .align(LV_ALIGN_CENTER) + .position(0, rowY) + .bgColor(0x2E7D32) + .onClick(s_onSettingsSaveClick, this) + .raw(); + + lv_obj_t* saveLabel = LvLabel(ui_SettingsSaveBtn) + #if defined(LANG_GR) + .text(LV_SYMBOL_SAVE " Αποθήκευση & Επανεκκίνηση") + #else + .text(LV_SYMBOL_SAVE " Save & Restart") + #endif + .font(&lv_font_arial_18) + .textColor(0xFFFFFF) + .raw(); + lv_obj_center(saveLabel); + rowY += 56; + + // Status label + ui_SettingsStatus = LvLabel(ui_TabPageSettings) + .text("") + .font(&lv_font_arial_18) + .textColor(0xFFC107) + .align(LV_ALIGN_CENTER) + .position(0, rowY); + + ui_Keyboard = LvKeyboard(lv_layer_top()) + .size(480, 200) + .align(LV_ALIGN_BOTTOM_MID) + .show(false) + .onEvent(s_onKeyboardEvent, this); + + // Refresh last-seen labels from Core 0 (LVGL task) every 30 s. + // updateContactLastSeen() only writes the data (Core 1, atomic), this + // timer does the actual lv_label_set_text() safely on Core 0. + lv_timer_create([](lv_timer_t* t) { + UIManager* self = (UIManager*) t->user_data; + self->refreshLastSeenLabels(); + }, 30000, this); +} + +void UIManager::setNightMode(bool night) { + if (!ui_DimOverlay) return; + if (night == night_mode_active) return; // debounce — avoids LVGL redraw every second + night_mode_active = night; + if (night) { + lv_obj_set_style_bg_color(ui_DimOverlay, lv_color_black(), 0); // explicit black + lv_obj_set_style_bg_opa(ui_DimOverlay, 192, 0); // 75% dark + } else { + lv_obj_set_style_bg_opa(ui_DimOverlay, 0, 0); // invisible + } +} + diff --git a/examples/simple_secure_chat_ui/uiTasks.cpp b/examples/simple_secure_chat_ui/uiTasks.cpp new file mode 100644 index 0000000000..b552204961 --- /dev/null +++ b/examples/simple_secure_chat_ui/uiTasks.cpp @@ -0,0 +1,50 @@ +#include + +#include "esp_log.h" +#include "uiDefines.h" +#include "uiTasks.h" +#include "uiVars.h" + +// Tasks +TaskHandle_t t_core0_lvgl; +TaskHandle_t t_core1_clock; +TaskHandle_t t_core1_core; + +#define TAG "createTasks" + +void createTasks() { + Serial.println("Creating Tasks..."); + + xTaskCreatePinnedToCore( + lvgl_task, // Task function. + "LVGL_Manager", // Name of task. + 10000, // Stack size of task + NULL, // Parameter of the task + 5, // Priority of the task + &t_core0_lvgl, // Task handle to keep track of created task + 0); // Pin task to core 0 + + xTaskCreatePinnedToCore( + core_task, // Task function. + "MeshCore", // Name of task. + 10000, // Stack size of task + NULL, // Parameter of the task + 4, // Priority of the task + &t_core1_core, // Task handle to keep track of created task + 1); // Pin task to core 1 + + xTaskCreatePinnedToCore( + clock_task, // Task function. + "CLOCK_Manager", // Name of task. + 10000, // Stack size of task + NULL, // Parameter of the task + 4, // Priority of the task + &t_core1_clock, // Task handle to keep track of created task + 1); // Pin task to core 1 + + ESP_LOGD(TAG, "All tasks created\nStarting tasks..."); + + vTaskResume(t_core0_lvgl); + vTaskResume(t_core1_clock); + +} diff --git a/include/lgfx.h b/include/lgfx.h new file mode 100644 index 0000000000..95cadb5482 --- /dev/null +++ b/include/lgfx.h @@ -0,0 +1,217 @@ +#ifndef LGFX_h +#define LGFX_h + +#include +#include +#include +#include + +#ifndef SEEED_SENSECAP_INDICATOR +class LGFX : public lgfx::LGFX_Device +{ +public: + + lgfx::Bus_RGB _bus_instance; + lgfx::Panel_RGB _panel_instance; + #if defined(ELECROW_DISPLAY_35) + LGFX(void) + { + { + auto cfg = _bus_instance.config(); + + cfg.port = 0; + cfg.freq_write = 80000000; + cfg.pin_wr = GPIO_NUM_18; + cfg.pin_rd = GPIO_NUM_48; + cfg.pin_rs = GPIO_NUM_45; + + cfg.pin_d0 = GPIO_NUM_47; + cfg.pin_d1 = GPIO_NUM_21; + cfg.pin_d2 = GPIO_NUM_14; + cfg.pin_d3 = GPIO_NUM_13; + cfg.pin_d4 = GPIO_NUM_12; + cfg.pin_d5 = GPIO_NUM_11; + cfg.pin_d6 = GPIO_NUM_10; + cfg.pin_d7 = GPIO_NUM_9; + cfg.pin_d8 = GPIO_NUM_3; + cfg.pin_d9 = GPIO_NUM_8; + cfg.pin_d10 = GPIO_NUM_16; + cfg.pin_d11 = GPIO_NUM_15; + cfg.pin_d12 = GPIO_NUM_7; + cfg.pin_d13 = GPIO_NUM_6; + cfg.pin_d14 = GPIO_NUM_5; + cfg.pin_d15 = GPIO_NUM_4; + + _bus_instance.config(cfg); + _panel_instance.setBus(&_bus_instance); + } + { + auto cfg = _panel_instance.config(); + + cfg.pin_cs = -1; + cfg.pin_rst = -1; + cfg.pin_busy = -1; + + cfg.memory_width = 320; + cfg.memory_height = 480; + cfg.panel_width = 320; + cfg.panel_height = 480; + cfg.offset_x = 0; + cfg.offset_y = 0; + cfg.offset_rotation = 0; + cfg.dummy_read_pixel = 8; + cfg.dummy_read_bits = 1; + cfg.readable = true; + cfg.invert = false; + cfg.rgb_order = false; + cfg.dlen_16bit = true; + cfg.bus_shared = true; + + _panel_instance.config(cfg); + } + setPanel(&_panel_instance); + } + + #elif defined(ELECROW_DISPLAY_50) + LGFX(void) + { + { + auto cfg = _bus_instance.config(); + cfg.panel = &_panel_instance; + + cfg.pin_d0 = GPIO_NUM_8; // B0 + cfg.pin_d1 = GPIO_NUM_3; // B1 + cfg.pin_d2 = GPIO_NUM_46; // B2 + cfg.pin_d3 = GPIO_NUM_9; // B3 + cfg.pin_d4 = GPIO_NUM_1; // B4 + + cfg.pin_d5 = GPIO_NUM_5; // G0 + cfg.pin_d6 = GPIO_NUM_6; // G1 + cfg.pin_d7 = GPIO_NUM_7; // G2 + cfg.pin_d8 = GPIO_NUM_15; // G3 + cfg.pin_d9 = GPIO_NUM_16; // G4 + cfg.pin_d10 = GPIO_NUM_4; // G5 + + cfg.pin_d11 = GPIO_NUM_45; // R0 + cfg.pin_d12 = GPIO_NUM_48; // R1 + cfg.pin_d13 = GPIO_NUM_47; // R2 + cfg.pin_d14 = GPIO_NUM_21; // R3 + cfg.pin_d15 = GPIO_NUM_14; // R4 + + cfg.pin_henable = GPIO_NUM_40; + cfg.pin_vsync = GPIO_NUM_41; + cfg.pin_hsync = GPIO_NUM_39; + cfg.pin_pclk = GPIO_NUM_0; + cfg.freq_write = 15000000; + + cfg.hsync_polarity = 0; + cfg.hsync_front_porch = 8; + cfg.hsync_pulse_width = 4; + cfg.hsync_back_porch = 43; + + cfg.vsync_polarity = 0; + cfg.vsync_front_porch = 8; + cfg.vsync_pulse_width = 4; + cfg.vsync_back_porch = 12; + + cfg.pclk_active_neg = 1; + cfg.de_idle_high = 0; + cfg.pclk_idle_high = 0; + + _bus_instance.config(cfg); + } + { + auto cfg = _panel_instance.config(); + cfg.memory_width = 800; + cfg.memory_height = 480; + cfg.panel_width = 800; + cfg.panel_height = 480; + cfg.offset_x = 0; + cfg.offset_y = 0; + _panel_instance.config(cfg); + } + _panel_instance.setBus(&_bus_instance); + setPanel(&_panel_instance); + } + #elif defined(ELECROW_DISPLAY_70) + // Constructor for the LGFX class. + LGFX(void) { + // Configure the RGB bus. + { + auto cfg = _bus_instance.config(); + cfg.panel = &_panel_instance; + + // Configure data pins. + cfg.pin_d0 = GPIO_NUM_15; // B0 + cfg.pin_d1 = GPIO_NUM_7; // B1 + cfg.pin_d2 = GPIO_NUM_6; // B2 + cfg.pin_d3 = GPIO_NUM_5; // B3 + cfg.pin_d4 = GPIO_NUM_4; // B4 + + cfg.pin_d5 = GPIO_NUM_9; // G0 + cfg.pin_d6 = GPIO_NUM_46; // G1 + cfg.pin_d7 = GPIO_NUM_3; // G2 + cfg.pin_d8 = GPIO_NUM_8; // G3 + cfg.pin_d9 = GPIO_NUM_16; // G4 + cfg.pin_d10 = GPIO_NUM_1; // G5 + + cfg.pin_d11 = GPIO_NUM_14; // R0 + cfg.pin_d12 = GPIO_NUM_21; // R1 + cfg.pin_d13 = GPIO_NUM_47; // R2 + cfg.pin_d14 = GPIO_NUM_48; // R3 + cfg.pin_d15 = GPIO_NUM_45; // R4 + + // Configure sync and clock pins. + cfg.pin_henable = GPIO_NUM_41; + cfg.pin_vsync = GPIO_NUM_40; + cfg.pin_hsync = GPIO_NUM_39; + cfg.pin_pclk = GPIO_NUM_0; + cfg.freq_write = 15000000; + + // Configure timing parameters for horizontal and vertical sync. + cfg.hsync_polarity = 0; + cfg.hsync_front_porch = 40; + cfg.hsync_pulse_width = 48; + cfg.hsync_back_porch = 40; + + cfg.vsync_polarity = 0; + cfg.vsync_front_porch = 1; + cfg.vsync_pulse_width = 31; + cfg.vsync_back_porch = 13; + + // Configure polarity for clock and data transmission. + cfg.pclk_active_neg = 1; + cfg.de_idle_high = 0; + cfg.pclk_idle_high = 0; + + // Apply configuration to the RGB bus instance. + _bus_instance.config(cfg); + } + + // Configure the panel. + { + auto cfg = _panel_instance.config(); + cfg.memory_width = 800; + cfg.memory_height = 480; + cfg.panel_width = 800; + cfg.panel_height = 480; + cfg.offset_x = 0; + cfg.offset_y = 0; + + // Apply configuration to the panel instance. + _panel_instance.config(cfg); + } + + // Set the RGB bus and panel instances. + _panel_instance.setBus(&_bus_instance); + setPanel(&_panel_instance); + } + #elif defined(SEEED_SENSECAP_INDICATOR) + + #else + #error "No Display size defined!" + #endif + +}; +#endif +#endif \ No newline at end of file diff --git a/include/lvBase.h b/include/lvBase.h new file mode 100644 index 0000000000..6aa3ff77ba --- /dev/null +++ b/include/lvBase.h @@ -0,0 +1,107 @@ +#ifndef LV_BASE_h +#define LV_BASE_h +#include "lvgl.h" + +template +class LvBase { +public: + operator lv_obj_t*() const { return obj; } + lv_obj_t* raw() const { return obj; } + + T& width(int v) { + lv_obj_set_width(obj, v == 100 ? lv_pct(100) : v); + return self(); + } + + T& height(int v) { + lv_obj_set_height(obj, v); + return self(); + } + + T& padAll(int v) { + lv_obj_set_style_pad_all(obj, v, 0); + return self(); + } + + T& bgOpa(int v) { + lv_obj_set_style_bg_opa(obj, v, 0); + return self(); + } + + T& border(int w) { + lv_obj_set_style_border_width(obj, w, 0); + return self(); + } + + T& scrollable(bool isScrollable) { + if (isScrollable) { + lv_obj_add_flag(obj, LV_OBJ_FLAG_SCROLLABLE); + lv_obj_set_scrollbar_mode(obj, LV_SCROLLBAR_MODE_AUTO); + } else { + lv_obj_clear_flag(obj, LV_OBJ_FLAG_SCROLLABLE); + lv_obj_set_scrollbar_mode(obj, LV_SCROLLBAR_MODE_OFF); + } + return self(); + } + + T& position(lv_coord_t x, lv_coord_t y) { + lv_obj_set_x(obj, x); + lv_obj_set_y(obj, y); + return self(); + } + + T& positionY(lv_coord_t y) { + lv_obj_set_y(obj, y); + return self(); + } + + T& positionX(lv_coord_t x) { + lv_obj_set_x(obj, x); + return self(); + } + + T& size(int w, int h) { + lv_obj_set_size(obj, w, h); + return self(); + } + + T& align(lv_align_t align) { + lv_obj_set_align(obj, align); + return self(); + } + + T& bgColor(uint32_t hex) { + lv_obj_set_style_bg_color(obj, lv_color_hex(hex), 0); + return self(); + } + + T& noDecor() { + lv_obj_set_style_outline_width(obj, 0, 0); + lv_obj_set_style_shadow_width(obj, 0, 0); + return self(); + } + + T& clickable(bool isClickable) { + if (isClickable) { + lv_obj_add_flag(obj, LV_OBJ_FLAG_CLICKABLE); + } else { + lv_obj_clear_flag(obj, LV_OBJ_FLAG_CLICKABLE); + } + return self(); + } + + T& onClick(lv_event_cb_t cb, void* user = nullptr) { + lv_obj_add_event_cb(obj, cb, LV_EVENT_CLICKED, user); + return self(); + } + +protected: + lv_obj_t* obj = nullptr; + +private: + T& self() { + return static_cast(*this); + } +}; + +#endif \ No newline at end of file diff --git a/include/lvButton.h b/include/lvButton.h new file mode 100644 index 0000000000..bee6d24e08 --- /dev/null +++ b/include/lvButton.h @@ -0,0 +1,12 @@ +#ifndef LV_BUTTON_h +#define LV_BUTTON_h + +#include "lvBase.h" + +class LvButton : public LvBase { +public: + explicit LvButton(lv_obj_t* parent) { + obj = lv_btn_create(parent); + } +}; +#endif \ No newline at end of file diff --git a/include/lvDropDown.h b/include/lvDropDown.h new file mode 100644 index 0000000000..fb9a64fc9c --- /dev/null +++ b/include/lvDropDown.h @@ -0,0 +1,23 @@ +#ifndef LV_DROP_DOWN_h +#define LV_DROP_DOWN_h + +#include "lvBase.h" + +class LvDropdown : public LvBase { +public: + explicit LvDropdown(lv_obj_t* parent) { + obj = lv_dropdown_create(parent); + } + + LvDropdown& options(const char* opts) { + lv_dropdown_set_options(obj, opts); + return *this; + } + + LvDropdown& selected(uint16_t idx) { + lv_dropdown_set_selected(obj, idx); + return *this; + } +}; + +#endif diff --git a/include/lvKeyboard.h b/include/lvKeyboard.h new file mode 100644 index 0000000000..7a4e586ce0 --- /dev/null +++ b/include/lvKeyboard.h @@ -0,0 +1,32 @@ +#ifndef LV_KEYBOARD_h +#define LV_KEYBOARD_h + +#include "lvBase.h" + +class LvKeyboard : public LvBase { +public: + explicit LvKeyboard(lv_obj_t* parent) { + obj = lv_keyboard_create(parent); + } + + explicit LvKeyboard(lv_obj_t* existing, bool) { + obj = existing; + } + + LvKeyboard& target(lv_obj_t* ta) { + lv_keyboard_set_textarea(obj, ta); + return *this; + } + + LvKeyboard& show(bool v = true) { + v ? lv_obj_clear_flag(obj, LV_OBJ_FLAG_HIDDEN) + : lv_obj_add_flag(obj, LV_OBJ_FLAG_HIDDEN); + return *this; + } + + LvKeyboard& onEvent(lv_event_cb_t cb, void* user = nullptr) { + lv_obj_add_event_cb(obj, cb, LV_EVENT_ALL, user); + return *this; + } +}; +#endif \ No newline at end of file diff --git a/include/lvLabel.h b/include/lvLabel.h new file mode 100644 index 0000000000..8073c94d3e --- /dev/null +++ b/include/lvLabel.h @@ -0,0 +1,41 @@ +#ifndef LV_LABEL_h +#define LV_LABEL_h + +#include "lvBase.h" + +class LvLabel : public LvBase { +public: + explicit LvLabel(lv_obj_t* parent) { + obj = lv_label_create(parent); + } + + LvLabel& text(const char* t) { + lv_label_set_text(obj, t); + return *this; + } + + LvLabel& font(const lv_font_t* f) { + lv_obj_set_style_text_font(obj, f, 0); + return *this; + } + + LvLabel& textColor(uint32_t hex) { + lv_obj_set_style_text_color(obj, lv_color_hex(hex), 0); + return *this; + } + + LvLabel& opa(int v) { + lv_obj_set_style_text_opa(obj, v, 0); + return *this; + } + + LvLabel& wrap(bool v = true) { + lv_label_set_long_mode( + obj, + v ? LV_LABEL_LONG_WRAP : LV_LABEL_LONG_CLIP + ); + return *this; + } +}; + +#endif \ No newline at end of file diff --git a/include/lvList.h b/include/lvList.h new file mode 100644 index 0000000000..17c4aaeadf --- /dev/null +++ b/include/lvList.h @@ -0,0 +1,28 @@ +#ifndef LV_LIST_h +#define LV_LIST_h + +#include "lvBase.h" + +class LvList : public LvBase { +public: + explicit LvList(lv_obj_t* parent) { + obj = lv_list_create(parent); + } + + LvList& transparent() { + lv_obj_set_style_bg_opa(obj, LV_OPA_TRANSP, 0); + lv_obj_set_style_border_width(obj, 0, 0); + + lv_obj_set_style_bg_opa(obj, LV_OPA_TRANSP, LV_PART_ITEMS); + lv_obj_set_style_border_width(obj, 0, LV_PART_ITEMS); + + return *this; + } + + LvList& padRow(int v) { + lv_obj_set_style_pad_row(obj, v, 0); + return *this; + } +}; + +#endif \ No newline at end of file diff --git a/include/lvObj.h b/include/lvObj.h new file mode 100644 index 0000000000..3024f5d550 --- /dev/null +++ b/include/lvObj.h @@ -0,0 +1,42 @@ +#ifndef LV_OBJ_h +#define LV_OBJ_h + +#include "lvBase.h" + +class LvObj : public LvBase { +public: + explicit LvObj(lv_obj_t* parent) { + obj = lv_obj_create(parent); + } + + explicit LvObj(lv_obj_t* existing, bool) { + obj = existing; + } + + LvObj& flexFlow(lv_flex_flow_t flow) { + lv_obj_set_flex_flow(obj, flow); + return *this; + } + + LvObj& flexAlign( + lv_flex_align_t main, + lv_flex_align_t cross, + lv_flex_align_t track = LV_FLEX_ALIGN_START + ) { + lv_obj_set_flex_align(obj, main, cross, track); + return *this; + } + + LvObj& bringToFront() { + lv_obj_move_foreground(obj); + return *this; + } + + LvObj& radius(int r) { + lv_obj_set_style_radius(obj, r, 0); + return *this; + } + +}; + +#endif \ No newline at end of file diff --git a/include/lvTabView.h b/include/lvTabView.h new file mode 100644 index 0000000000..6d0306e45f --- /dev/null +++ b/include/lvTabView.h @@ -0,0 +1,51 @@ +#ifndef LV_TAB_VIEW_h +#define LV_TAB_VIEW_h + +#include "lvBase.h" + +class LvTabView : public LvBase { +public: + explicit LvTabView(lv_obj_t* parent, + lv_dir_t dir = LV_DIR_TOP, + int tab_h = 50) { + obj = lv_tabview_create(parent, dir, tab_h); + } + + lv_obj_t* addTab(const char* name) { + return lv_tabview_add_tab(obj, name); + } + + LvTabView& contentNoScroll() { + lv_obj_clear_flag( + lv_tabview_get_content(obj), + LV_OBJ_FLAG_SCROLLABLE + ); + return *this; + } + + LvTabView& tabBtnBg(uint32_t hex) { + lv_obj_set_style_bg_color( + lv_tabview_get_tab_btns(obj), + lv_color_hex(hex), + 0 + ); + return *this; + } + + LvTabView& tabBtnText(uint32_t hex, const lv_font_t* f = nullptr) { + lv_obj_set_style_text_color( + lv_tabview_get_tab_btns(obj), + lv_color_hex(hex), + LV_PART_ITEMS + ); + if (f) { + lv_obj_set_style_text_font( + lv_tabview_get_tab_btns(obj), + f, + LV_PART_ITEMS + ); + } + return *this; + } +}; +#endif \ No newline at end of file diff --git a/include/lvTextArea.h b/include/lvTextArea.h new file mode 100644 index 0000000000..7b7f432223 --- /dev/null +++ b/include/lvTextArea.h @@ -0,0 +1,52 @@ +#ifndef LV_TEXT_AREA_h +#define LV_TEXT_AREA_h + +#include "lvBase.h" + +class LvTextArea : public LvBase { +public: + explicit LvTextArea(lv_obj_t* parent) { + obj = lv_textarea_create(parent); + } + + LvTextArea& oneLine(bool v = true) { + lv_textarea_set_one_line(obj, v); + return *this; + } + + LvTextArea& placeholder(const char* txt) { + lv_textarea_set_placeholder_text(obj, txt); + return *this; + } + + LvTextArea& font(const lv_font_t* f) { + lv_obj_set_style_text_font(obj, f, 0); + return *this; + } + + LvTextArea& textColor(uint32_t hex) { + lv_obj_set_style_text_color(obj, lv_color_hex(hex), 0); + return *this; + } + + LvTextArea& borderColor(uint32_t hex) { + lv_obj_set_style_border_color(obj, lv_color_hex(hex), 0); + return *this; + } + + LvTextArea& borderWidth(int w) { + lv_obj_set_style_border_width(obj, w, 0); + return *this; + } + + LvTextArea& radius(int r) { + lv_obj_set_style_radius(obj, r, 0); + return *this; + } + + LvTextArea& onFocus(lv_event_cb_t cb, void* user = nullptr) { + lv_obj_add_event_cb(obj, cb, LV_EVENT_CLICKED, user); + return *this; + } +}; +#endif \ No newline at end of file diff --git a/include/uiDefines.h b/include/uiDefines.h new file mode 100644 index 0000000000..d5cc65eca5 --- /dev/null +++ b/include/uiDefines.h @@ -0,0 +1,61 @@ +#ifndef DEFINES_h +#define DEFINES_h + + +#define BUTTONS_ON_SCREEN 7 + +#define DELAY_CORE_TASK 5 +#define DELAY_LVGL_TASK 10 +#define DELAY_MAIN_TASK 500 +#define DELAY_CLOCK_TASK 1000 +#define DELAY_NTP_TASK 30000 +#define DELAY_WIFI_RECONNECT_TASK 5000 +// every 5 minutes on success +#define DELAY_OPEN_WEATHER_TASK 300000 +// every 1 minute on failure +#define DELAY_OPEN_WEATHER_SHORT_TASK 60000 + +#define STATE_OFF HIGH +#define STATE_ON LOW + +#define MAX_CHAT_MESSAGES 50 + +// Colors +#define COLOR_WHITE 0xFFFFFF +#define COLOR_BLACK 0 +#define COLOR_RED 0xFF0000 +#define COLOR_BLUE 0x0077FF +#define COLOR_BLUE_LIGHT 0x22A8FD +#define COLOR_GREY 0x8F8F8F +#define BUTTON_BACKGROUND 0x1B1B1B + +// Device Elecrow 5 & 7 inches +#define SD_MOSI 11 +#define SD_MISO 13 +#define SD_SCK 12 +#define SD_CS 10 + +#define I2S_DOUT 17 +#define I2S_BCLK 42 +#define I2S_LRC 18 + +#define GPIO_D 38 + +#define UART_RX 44 +#define UART_TX 43 +#define I2C_SDA 19 +#define I2C_SCL 20 +#define LCD_Backlight 2 + +// Contact list: show avatar circle with initials (disable on small screens) +//#define SHOW_CONTACT_AVATAR + +// Other defines +#define DELAY_MAIN_TASK 10 +#define DELAY_REFRESH_VIEW 10 +#define OLED_RESET -1 + +#define TFT_BL 2 +#define LGFX_USE_V1 + +#endif diff --git a/include/uiExternals.h b/include/uiExternals.h new file mode 100644 index 0000000000..0928fd3a9c --- /dev/null +++ b/include/uiExternals.h @@ -0,0 +1,11 @@ +#ifndef EXTERNALS_h +#define EXTERNALS_h + +#include + +extern void createTasks(); +extern TaskHandle_t t_core0_lvgl; +extern TaskHandle_t t_core1_clock; +extern TaskHandle_t t_core1_core; + +#endif \ No newline at end of file diff --git a/include/uiManager.h b/include/uiManager.h new file mode 100644 index 0000000000..15ab3f9f4d --- /dev/null +++ b/include/uiManager.h @@ -0,0 +1,145 @@ +#ifndef UI_MANAGER_h +#define UI_MANAGER_h + +#include +#include "uiDefines.h" + +#include "lvButton.h" +#include "lvDropDown.h" +#include "lvKeyboard.h" +#include "lvLabel.h" +#include "lvList.h" +#include "lvObj.h" +#include "lvTabView.h" +#include "lvTextArea.h" + +#include + +class UIManager { + private: + // functions + void format_datetime(char *buf, size_t size, const struct tm *timeinfo); + void timestampToTime(time_t timestamp, char *buffer, size_t buffer_size); + const char* convertDegreesToDirection(int degrees); + int windSpeedToBeaufort(float speed); + void getInitials(const char *name, char *out); + void formatLastSeen(uint32_t ts, char *out, size_t len); + void format_time(uint32_t ts, char *buf, size_t len); + + // Calendar days and months + static const char *days[7]; + static const char *months[12]; + + // vars + char time_str[9]; + String lastUpdate = ""; + char* tmp_buf; + + lv_obj_t *chat_items[MAX_CHAT_MESSAGES]; + int chat_count = 0; + int channelInputBaseY = 185; + int channelInputBaseKeybOnY = -15; + void onShowKeyboard(); + void onHideKeyboard(); + void ui_Screen1_screen_init(void); + + lv_obj_t* ui_Screen1; + lv_obj_t* ui_TabView1; + lv_obj_t* ui_TabPageContacts; + lv_obj_t* ui_Contacts; + lv_obj_t* ui_ContactMessages; + lv_obj_t* ui_TabPageChannels; + lv_obj_t* ui_Channels; + lv_obj_t* ui_ChannelMessages; + lv_obj_t* ui_AutoLight; + lv_obj_t* ui____initial_actions0; + + lv_obj_t* ui_DimOverlay; + lv_obj_t* ui_TabPageHome; + lv_obj_t* ui_ValueDate; + lv_obj_t* ui_ValueTime; + lv_obj_t* ui_TabPageSettings; + lv_obj_t* ui_DayLight; + lv_obj_t* ui_ChannelInput; + lv_obj_t* ui_SendBtn; + lv_obj_t* ui_Keyboard; + lv_obj_t* iu_SendLabel; + lv_obj_t* ui_ChannelDivider; + + lv_obj_t* ui_ContactName = nullptr; + lv_obj_t* ui_ContactInput = nullptr; + lv_obj_t* ui_ContactSendBtn = nullptr; + lv_obj_t* ui_ContactSendLabel = nullptr; + char currentContactName[32] = {0}; + uint8_t currentContactPubKey[32] = {0}; + bool hasCurrentContact = false; + bool night_mode_active = false; + char myNodeName[32] = {0}; + + lv_obj_t* ui_ContactStatus = nullptr; + + lv_obj_t* ui_HomeNodeName = nullptr; + lv_obj_t* ui_HomePubKey = nullptr; + lv_obj_t* ui_HomeInfo = nullptr; + lv_obj_t* ui_AdvertiseBtn = nullptr; + + lv_obj_t* ui_SettingsName = nullptr; + lv_obj_t* ui_SettingsPreset = nullptr; + lv_obj_t* ui_SettingsFreq = nullptr; + lv_obj_t* ui_SettingsBw = nullptr; + lv_obj_t* ui_SettingsSf = nullptr; + lv_obj_t* ui_SettingsCr = nullptr; + lv_obj_t* ui_SettingsTx = nullptr; + lv_obj_t* ui_SettingsFw = nullptr; + lv_obj_t* ui_SettingsSaveBtn = nullptr; + lv_obj_t* ui_SettingsStatus = nullptr; + + // Whichever input/send button last got focus — used by keyboard show/hide + lv_obj_t* activeInput = nullptr; + lv_obj_t* activeSendBtn = nullptr; + int activeInputBaseY = 0; + + public: + UIManager(); + + void onChannelInputFocus(lv_event_t* e); + void onContactInputFocus(lv_event_t* e); + void onContactSendClick(lv_event_t* e); + void onSettingsInputFocus(lv_event_t* e); + void onSettingsSaveClick(lv_event_t* e); + void onAdvertiseClick(lv_event_t* e); + void onDimOverlayClick(lv_event_t* e); + void onSendClick(lv_event_t* e); + void onKeyboardEvent(lv_event_t* e); + void scroll_begin_event(lv_event_t* e); + + void onPresetChange(uint16_t idx); + void populateSettings(const char* name, float freq, float bw, uint8_t sf, uint8_t cr, + uint8_t tx_power, const char* fw_ver, const char* build_date); + void populateHome(const char* name, const char* pub_key_hex, + int contact_count, float freq); + void setMyNodeName(const char* name); + + // Phase 6 + void routeIncomingDM(const uint8_t* from_pub_key, const char* from_name, + const char* time_str, const char* text); + void setSendStatus(int state); // 0=sending, 1=delivered, 2=failed, -1=clear + + void updateDateTime(const struct tm timeinfo); + void updateInfo(const char *str, uint32_t color); + void clearDateTime(); + void updateValues(); + void addPrivateChatBubble(const char *time_str, const char *msg, bool is_self, bool do_scroll = true); + void addChatBubble(const char *time_str, const char *sender, const char *msg, bool is_self, bool do_scroll = true); + void scrollPrivateChatToBottom(); + void scrollPublicChatToBottom(); + void beginPublicHistoryLoad(); // disable flex before bulk load + void endPublicHistoryLoad(); // re-enable flex after bulk load + void addContactToUI(ContactInfo c); + void updateContactLastSeen(const uint8_t* pub_key, uint32_t lastmod); + void refreshLastSeenLabels(); + void handleContactClick(lv_event_t *e); + void setNightMode(bool night); +}; + +#endif \ No newline at end of file diff --git a/include/uiTasks.h b/include/uiTasks.h new file mode 100644 index 0000000000..982a889959 --- /dev/null +++ b/include/uiTasks.h @@ -0,0 +1,12 @@ +#ifndef TASKS_h +#define TASKS_h + +#include +#include "uiDefines.h" +#include "uiVars.h" + +void lvgl_task(void *pvParameters); +void clock_task(void *pvParameters); +void core_task(void *pvParameters); + +#endif \ No newline at end of file diff --git a/include/uiTouch.h b/include/uiTouch.h new file mode 100644 index 0000000000..8e60b927d1 --- /dev/null +++ b/include/uiTouch.h @@ -0,0 +1,220 @@ +/******************************************************************************* + * Touch libraries: + * FT6X36: https://github.com/strange-v/FT6X36.git + * GT911: https://github.com/TAMCTec/gt911-arduino.git + * XPT2046: https://github.com/PaulStoffregen/XPT2046_Touchscreen.git + ******************************************************************************/ + +/* uncomment for FT6X36 */ +// #define TOUCH_FT6X36 +// #define TOUCH_FT6X36_SCL 38//19 +// #define TOUCH_FT6X36_SDA 37//18 +// #define TOUCH_FT6X36_INT 4//39 +// #define TOUCH_SWAP_XY +// #define TOUCH_MAP_X1 800 +// #define TOUCH_MAP_X2 0 +// #define TOUCH_MAP_Y1 0 +// #define TOUCH_MAP_Y2 480 + +/* uncomment for GT911 */ +// #define TOUCH_GT911 +// #define TOUCH_GT911_SCL 20//20 +// #define TOUCH_GT911_SDA 19//19 +// #define TOUCH_GT911_INT -1//-1 +// #define TOUCH_GT911_RST -1//38 +// #define TOUCH_GT911_ROTATION ROTATION_NORMAL +// #define TOUCH_MAP_X1 800//480 +// #define TOUCH_MAP_X2 0 +// #define TOUCH_MAP_Y1 480//272 +// #define TOUCH_MAP_Y2 0 + +/* uncomment for XPT2046 */ +// #define TOUCH_XPT2046 +// #define TOUCH_XPT2046_SCK 12 +// #define TOUCH_XPT2046_MISO 13 +// #define TOUCH_XPT2046_MOSI 11 +// #define TOUCH_XPT2046_CS 38 +// #define TOUCH_XPT2046_INT 36 +// #define TOUCH_XPT2046_ROTATION 0 +// #define TOUCH_MAP_X1 4000 +// #define TOUCH_MAP_X2 100 +// #define TOUCH_MAP_Y1 100 +// #define TOUCH_MAP_Y2 4000 + +LGFX lcd; + +int touch_last_x = 0, touch_last_y = 0; + +#if defined(TOUCH_FT6X36) +#include +#include +FT6X36 ts(&Wire, TOUCH_FT6X36_INT); +bool touch_touched_flag = true, touch_released_flag = true; + +#elif defined(TOUCH_GT911) +#include +#include +TAMC_GT911 ts = TAMC_GT911(TOUCH_GT911_SDA, TOUCH_GT911_SCL, TOUCH_GT911_INT, TOUCH_GT911_RST, max(TOUCH_MAP_X1, TOUCH_MAP_X2), max(TOUCH_MAP_Y1, TOUCH_MAP_Y2)); + +#elif defined(TOUCH_XPT2046) +#include +#include +XPT2046_Touchscreen ts(TOUCH_XPT2046_CS, TOUCH_XPT2046_INT); + +#endif + +#if defined(TOUCH_FT6X36) +void touch(TPoint p, TEvent e) +{ + if (e != TEvent::Tap && e != TEvent::DragStart && e != TEvent::DragMove && e != TEvent::DragEnd) + { + return; + } + // translation logic depends on screen rotation +#if defined(TOUCH_SWAP_XY) + touch_last_x = map(p.y, TOUCH_MAP_X1, TOUCH_MAP_X2, 0, lcd.width()); + touch_last_y = map(p.x, TOUCH_MAP_Y1, TOUCH_MAP_Y2, 0, lcd.height()); +#else + touch_last_x = map(p.x, TOUCH_MAP_X1, TOUCH_MAP_X2, 0, lcd.width()); + touch_last_y = map(p.y, TOUCH_MAP_Y1, TOUCH_MAP_Y2, 0, lcd.height()); +#endif + switch (e) + { + case TEvent::Tap: + Serial.println("Tap"); + touch_touched_flag = true; + touch_released_flag = true; + break; + case TEvent::DragStart: + Serial.println("DragStart"); + touch_touched_flag = true; + break; + case TEvent::DragMove: + Serial.println("DragMove"); + touch_touched_flag = true; + break; + case TEvent::DragEnd: + Serial.println("DragEnd"); + touch_released_flag = true; + break; + default: + Serial.println("UNKNOWN"); + break; + } +} +#endif + +void touch_init() +{ +#if defined(TOUCH_FT6X36) + Wire.begin(TOUCH_FT6X36_SDA, TOUCH_FT6X36_SCL); + ts.begin(); + ts.registerTouchHandler(touch); + +#elif defined(TOUCH_GT911) + Wire.begin(TOUCH_GT911_SDA, TOUCH_GT911_SCL); + ts.begin(); + ts.setRotation(TOUCH_GT911_ROTATION); + +#elif defined(TOUCH_XPT2046) + SPI.begin(TOUCH_XPT2046_SCK, TOUCH_XPT2046_MISO, TOUCH_XPT2046_MOSI, TOUCH_XPT2046_CS); + ts.begin(); + ts.setRotation(TOUCH_XPT2046_ROTATION); + +#endif +} + +bool touch_has_signal() +{ +#if defined(TOUCH_FT6X36) + ts.loop(); + return touch_touched_flag || touch_released_flag; + +#elif defined(TOUCH_GT911) + return true; + +#elif defined(TOUCH_XPT2046) + return ts.tirqTouched(); + +#else + return false; +#endif +} + +bool touch_touched() +{ +#if defined(TOUCH_FT6X36) + if (touch_touched_flag) + { + touch_touched_flag = false; + return true; + } + else + { + return false; + } + +#elif defined(TOUCH_GT911) + ts.read(); + if (ts.isTouched) + { +#if defined(TOUCH_SWAP_XY) + touch_last_x = map(ts.points[0].y, TOUCH_MAP_X1, TOUCH_MAP_X2, 0, lcd.width() - 1); + touch_last_y = map(ts.points[0].x, TOUCH_MAP_Y1, TOUCH_MAP_Y2, 0, lcd.height() - 1); +#else + touch_last_x = map(ts.points[0].x, TOUCH_MAP_X1, TOUCH_MAP_X2, 0, lcd.width() - 1); + touch_last_y = map(ts.points[0].y, TOUCH_MAP_Y1, TOUCH_MAP_Y2, 0, lcd.height() - 1); +#endif + return true; + } + else + { + return false; + } + +#elif defined(TOUCH_XPT2046) + if (ts.touched()) + { + TS_Point p = ts.getPoint(); +#if defined(TOUCH_SWAP_XY) + touch_last_x = map(p.y, TOUCH_MAP_X1, TOUCH_MAP_X2, 0, lcd.width() - 1); + touch_last_y = map(p.x, TOUCH_MAP_Y1, TOUCH_MAP_Y2, 0, lcd.height() - 1); +#else + touch_last_x = map(p.x, TOUCH_MAP_X1, TOUCH_MAP_X2, 0, lcd.width() - 1); + touch_last_y = map(p.y, TOUCH_MAP_Y1, TOUCH_MAP_Y2, 0, lcd.height() - 1); +#endif + return true; + } + else + { + return false; + } + +#else + return false; +#endif +} + +bool touch_released() +{ +#if defined(TOUCH_FT6X36) + if (touch_released_flag) + { + touch_released_flag = false; + return true; + } + else + { + return false; + } + +#elif defined(TOUCH_GT911) + return true; + +#elif defined(TOUCH_XPT2046) + return true; + +#else + return false; +#endif +} diff --git a/include/uiVars.h b/include/uiVars.h new file mode 100644 index 0000000000..a04ff6ac1b --- /dev/null +++ b/include/uiVars.h @@ -0,0 +1,22 @@ +#ifndef VARS_h +#define VARS_h + +#include +#include "lvgl.h" +#include "uiManager.h" + +extern void createTasks(); + +extern TaskHandle_t t_core1_tft; +extern TaskHandle_t t_core0_lvgl; +extern TaskHandle_t t_core1_clock; +extern TaskHandle_t t_core1_core; + +extern SemaphoreHandle_t semaphoreData; + +extern UIManager *uiManager; +extern lv_obj_t * ui_MainTabView; + +extern volatile bool g_clock_synced; + +#endif \ No newline at end of file diff --git a/lib/lvgl/lv_conf.h b/lib/lvgl/lv_conf.h new file mode 100644 index 0000000000..b5e9f82ac0 --- /dev/null +++ b/lib/lvgl/lv_conf.h @@ -0,0 +1,787 @@ +/** + * @file lv_conf.h + * Configuration file for v8.3.11 + */ + +/* + * Copy this file as `lv_conf.h` + * 1. simply next to the `lvgl` folder + * 2. or any other places and + * - define `LV_CONF_INCLUDE_SIMPLE` + * - add the path as include path + */ + +/* clang-format off */ +#if 1 /*Set it to "1" to enable content*/ + +#ifndef LV_CONF_H +#define LV_CONF_H + +#include + +/*==================== + COLOR SETTINGS + *====================*/ + +/*Color depth: 1 (1 byte per pixel), 8 (RGB332), 16 (RGB565), 32 (ARGB8888)*/ +#define LV_COLOR_DEPTH 16 + +/*Swap the 2 bytes of RGB565 color. Useful if the display has an 8-bit interface (e.g. SPI)*/ +#define LV_COLOR_16_SWAP 0 + +/*Enable features to draw on transparent background. + *It's required if opa, and transform_* style properties are used. + *Can be also used if the UI is above another layer, e.g. an OSD menu or video player.*/ +#define LV_COLOR_SCREEN_TRANSP 0 + +/* Adjust color mix functions rounding. GPUs might calculate color mix (blending) differently. + * 0: round down, 64: round up from x.75, 128: round up from half, 192: round up from x.25, 254: round up */ +#define LV_COLOR_MIX_ROUND_OFS 0 + +/*Images pixels with this color will not be drawn if they are chroma keyed)*/ +#define LV_COLOR_CHROMA_KEY lv_color_hex(0x00ff00) /*pure green*/ + +/*========================= + MEMORY SETTINGS + *=========================*/ + +/*1: use custom malloc/free, 0: use the built-in `lv_mem_alloc()` and `lv_mem_free()`*/ +/* ESP32-S3 has 8 MB OPI PSRAM. Switching to LV_MEM_CUSTOM=1 lets LVGL use the + system heap (which includes PSRAM on this board) instead of a fixed 48 KB + static pool. This prevents OOM crashes when loading many chat bubbles. */ +#define LV_MEM_CUSTOM 1 +#if LV_MEM_CUSTOM == 0 + /*Size of the memory available for `lv_mem_alloc()` in bytes (>= 2kB)*/ + #define LV_MEM_SIZE (48U * 1024U) /*[bytes]*/ + + /*Set an address for the memory pool instead of allocating it as a normal array. Can be in external SRAM too.*/ + #define LV_MEM_ADR 0 /*0: unused*/ + /*Instead of an address give a memory allocator that will be called to get a memory pool for LVGL. E.g. my_malloc*/ + #if LV_MEM_ADR == 0 + #undef LV_MEM_POOL_INCLUDE + #undef LV_MEM_POOL_ALLOC + #endif + +#else /*LV_MEM_CUSTOM*/ + #define LV_MEM_CUSTOM_INCLUDE /*Header for the dynamic memory function*/ + #define LV_MEM_CUSTOM_ALLOC malloc + #define LV_MEM_CUSTOM_FREE free + #define LV_MEM_CUSTOM_REALLOC realloc +#endif /*LV_MEM_CUSTOM*/ + +/*Number of the intermediate memory buffer used during rendering and other internal processing mechanisms. + *You will see an error log message if there wasn't enough buffers. */ +#define LV_MEM_BUF_MAX_NUM 16 + +/*Use the standard `memcpy` and `memset` instead of LVGL's own functions. (Might or might not be faster).*/ +#define LV_MEMCPY_MEMSET_STD 0 + +/*==================== + HAL SETTINGS + *====================*/ + +/*Default display refresh period. LVG will redraw changed areas with this period time*/ +#define LV_DISP_DEF_REFR_PERIOD 10 /*[ms]*/ + +/*Input device read period in milliseconds*/ +#define LV_INDEV_DEF_READ_PERIOD 30 /*[ms]*/ + +/*Use a custom tick source that tells the elapsed time in milliseconds. + *It removes the need to manually update the tick with `lv_tick_inc()`)*/ +#define LV_TICK_CUSTOM 1 +#if LV_TICK_CUSTOM + #define LV_TICK_CUSTOM_INCLUDE "Arduino.h" /*Header for the system time function*/ + #define LV_TICK_CUSTOM_SYS_TIME_EXPR (millis()) /*Expression evaluating to current system time in ms*/ + /*If using lvgl as ESP32 component*/ + // #define LV_TICK_CUSTOM_INCLUDE "esp_timer.h" + // #define LV_TICK_CUSTOM_SYS_TIME_EXPR ((esp_timer_get_time() / 1000LL)) +#endif /*LV_TICK_CUSTOM*/ + +/*Default Dot Per Inch. Used to initialize default sizes such as widgets sized, style paddings. + *(Not so important, you can adjust it to modify default sizes and spaces)*/ +#define LV_DPI_DEF 130 /*[px/inch]*/ + +/*======================= + * FEATURE CONFIGURATION + *=======================*/ + +/*------------- + * Drawing + *-----------*/ + +/*Enable complex draw engine. + *Required to draw shadow, gradient, rounded corners, circles, arc, skew lines, image transformations or any masks*/ +#define LV_DRAW_COMPLEX 1 +#if LV_DRAW_COMPLEX != 0 + + /*Allow buffering some shadow calculation. + *LV_SHADOW_CACHE_SIZE is the max. shadow size to buffer, where shadow size is `shadow_width + radius` + *Caching has LV_SHADOW_CACHE_SIZE^2 RAM cost*/ + #define LV_SHADOW_CACHE_SIZE 0 + + /* Set number of maximally cached circle data. + * The circumference of 1/4 circle are saved for anti-aliasing + * radius * 4 bytes are used per circle (the most often used radiuses are saved) + * 0: to disable caching */ + #define LV_CIRCLE_CACHE_SIZE 4 +#endif /*LV_DRAW_COMPLEX*/ + +/** + * "Simple layers" are used when a widget has `style_opa < 255` to buffer the widget into a layer + * and blend it as an image with the given opacity. + * Note that `bg_opa`, `text_opa` etc don't require buffering into layer) + * The widget can be buffered in smaller chunks to avoid using large buffers. + * + * - LV_LAYER_SIMPLE_BUF_SIZE: [bytes] the optimal target buffer size. LVGL will try to allocate it + * - LV_LAYER_SIMPLE_FALLBACK_BUF_SIZE: [bytes] used if `LV_LAYER_SIMPLE_BUF_SIZE` couldn't be allocated. + * + * Both buffer sizes are in bytes. + * "Transformed layers" (where transform_angle/zoom properties are used) use larger buffers + * and can't be drawn in chunks. So these settings affects only widgets with opacity. + */ +#define LV_LAYER_SIMPLE_BUF_SIZE (24 * 1024) +#define LV_LAYER_SIMPLE_FALLBACK_BUF_SIZE (3 * 1024) + +/*Default image cache size. Image caching keeps the images opened. + *If only the built-in image formats are used there is no real advantage of caching. (I.e. if no new image decoder is added) + *With complex image decoders (e.g. PNG or JPG) caching can save the continuous open/decode of images. + *However the opened images might consume additional RAM. + *0: to disable caching*/ +#define LV_IMG_CACHE_DEF_SIZE 0 + +/*Number of stops allowed per gradient. Increase this to allow more stops. + *This adds (sizeof(lv_color_t) + 1) bytes per additional stop*/ +#define LV_GRADIENT_MAX_STOPS 2 + +/*Default gradient buffer size. + *When LVGL calculates the gradient "maps" it can save them into a cache to avoid calculating them again. + *LV_GRAD_CACHE_DEF_SIZE sets the size of this cache in bytes. + *If the cache is too small the map will be allocated only while it's required for the drawing. + *0 mean no caching.*/ +#define LV_GRAD_CACHE_DEF_SIZE 0 + +/*Allow dithering the gradients (to achieve visual smooth color gradients on limited color depth display) + *LV_DITHER_GRADIENT implies allocating one or two more lines of the object's rendering surface + *The increase in memory consumption is (32 bits * object width) plus 24 bits * object width if using error diffusion */ +#define LV_DITHER_GRADIENT 0 +#if LV_DITHER_GRADIENT + /*Add support for error diffusion dithering. + *Error diffusion dithering gets a much better visual result, but implies more CPU consumption and memory when drawing. + *The increase in memory consumption is (24 bits * object's width)*/ + #define LV_DITHER_ERROR_DIFFUSION 0 +#endif + +/*Maximum buffer size to allocate for rotation. + *Only used if software rotation is enabled in the display driver.*/ +#define LV_DISP_ROT_MAX_BUF (10*1024) + +/*------------- + * GPU + *-----------*/ + +/*Use Arm's 2D acceleration library Arm-2D */ +#define LV_USE_GPU_ARM2D 0 + +/*Use STM32's DMA2D (aka Chrom Art) GPU*/ +#define LV_USE_GPU_STM32_DMA2D 0 +#if LV_USE_GPU_STM32_DMA2D + /*Must be defined to include path of CMSIS header of target processor + e.g. "stm32f7xx.h" or "stm32f4xx.h"*/ + #define LV_GPU_DMA2D_CMSIS_INCLUDE +#endif + +/*Enable RA6M3 G2D GPU*/ +#define LV_USE_GPU_RA6M3_G2D 0 +#if LV_USE_GPU_RA6M3_G2D + /*include path of target processor + e.g. "hal_data.h"*/ + #define LV_GPU_RA6M3_G2D_INCLUDE "hal_data.h" +#endif + +/*Use SWM341's DMA2D GPU*/ +#define LV_USE_GPU_SWM341_DMA2D 0 +#if LV_USE_GPU_SWM341_DMA2D + #define LV_GPU_SWM341_DMA2D_INCLUDE "SWM341.h" +#endif + +/*Use NXP's PXP GPU iMX RTxxx platforms*/ +#define LV_USE_GPU_NXP_PXP 0 +#if LV_USE_GPU_NXP_PXP + /*1: Add default bare metal and FreeRTOS interrupt handling routines for PXP (lv_gpu_nxp_pxp_osa.c) + * and call lv_gpu_nxp_pxp_init() automatically during lv_init(). Note that symbol SDK_OS_FREE_RTOS + * has to be defined in order to use FreeRTOS OSA, otherwise bare-metal implementation is selected. + *0: lv_gpu_nxp_pxp_init() has to be called manually before lv_init() + */ + #define LV_USE_GPU_NXP_PXP_AUTO_INIT 0 +#endif + +/*Use NXP's VG-Lite GPU iMX RTxxx platforms*/ +#define LV_USE_GPU_NXP_VG_LITE 0 + +/*Use SDL renderer API*/ +#define LV_USE_GPU_SDL 0 +#if LV_USE_GPU_SDL + #define LV_GPU_SDL_INCLUDE_PATH + /*Texture cache size, 8MB by default*/ + #define LV_GPU_SDL_LRU_SIZE (1024 * 1024 * 8) + /*Custom blend mode for mask drawing, disable if you need to link with older SDL2 lib*/ + #define LV_GPU_SDL_CUSTOM_BLEND_MODE (SDL_VERSION_ATLEAST(2, 0, 6)) +#endif + +/*------------- + * Logging + *-----------*/ + +/*Enable the log module*/ +#define LV_USE_LOG 0 +#if LV_USE_LOG + + /*How important log should be added: + *LV_LOG_LEVEL_TRACE A lot of logs to give detailed information + *LV_LOG_LEVEL_INFO Log important events + *LV_LOG_LEVEL_WARN Log if something unwanted happened but didn't cause a problem + *LV_LOG_LEVEL_ERROR Only critical issue, when the system may fail + *LV_LOG_LEVEL_USER Only logs added by the user + *LV_LOG_LEVEL_NONE Do not log anything*/ + #define LV_LOG_LEVEL LV_LOG_LEVEL_WARN + + /*1: Print the log with 'printf'; + *0: User need to register a callback with `lv_log_register_print_cb()`*/ + #define LV_LOG_PRINTF 0 + + /*Enable/disable LV_LOG_TRACE in modules that produces a huge number of logs*/ + #define LV_LOG_TRACE_MEM 1 + #define LV_LOG_TRACE_TIMER 1 + #define LV_LOG_TRACE_INDEV 1 + #define LV_LOG_TRACE_DISP_REFR 1 + #define LV_LOG_TRACE_EVENT 1 + #define LV_LOG_TRACE_OBJ_CREATE 1 + #define LV_LOG_TRACE_LAYOUT 1 + #define LV_LOG_TRACE_ANIM 1 + +#endif /*LV_USE_LOG*/ + +/*------------- + * Asserts + *-----------*/ + +/*Enable asserts if an operation is failed or an invalid data is found. + *If LV_USE_LOG is enabled an error message will be printed on failure*/ +#define LV_USE_ASSERT_NULL 1 /*Check if the parameter is NULL. (Very fast, recommended)*/ +#define LV_USE_ASSERT_MALLOC 1 /*Checks is the memory is successfully allocated or no. (Very fast, recommended)*/ +#define LV_USE_ASSERT_STYLE 0 /*Check if the styles are properly initialized. (Very fast, recommended)*/ +#define LV_USE_ASSERT_MEM_INTEGRITY 0 /*Check the integrity of `lv_mem` after critical operations. (Slow)*/ +#define LV_USE_ASSERT_OBJ 0 /*Check the object's type and existence (e.g. not deleted). (Slow)*/ + +/*Add a custom handler when assert happens e.g. to restart the MCU*/ +#define LV_ASSERT_HANDLER_INCLUDE +#define LV_ASSERT_HANDLER while(1); /*Halt by default*/ + +/*------------- + * Others + *-----------*/ + +/*1: Show CPU usage and FPS count*/ +#define LV_USE_PERF_MONITOR 0 +#if LV_USE_PERF_MONITOR + #define LV_USE_PERF_MONITOR_POS LV_ALIGN_BOTTOM_RIGHT +#endif + +/*1: Show the used memory and the memory fragmentation + * Requires LV_MEM_CUSTOM = 0*/ +#define LV_USE_MEM_MONITOR 0 +#if LV_USE_MEM_MONITOR + #define LV_USE_MEM_MONITOR_POS LV_ALIGN_BOTTOM_LEFT +#endif + +/*1: Draw random colored rectangles over the redrawn areas*/ +#define LV_USE_REFR_DEBUG 0 + +/*Change the built in (v)snprintf functions*/ +#define LV_SPRINTF_CUSTOM 0 +#if LV_SPRINTF_CUSTOM + #define LV_SPRINTF_INCLUDE + #define lv_snprintf snprintf + #define lv_vsnprintf vsnprintf +#else /*LV_SPRINTF_CUSTOM*/ + #define LV_SPRINTF_USE_FLOAT 0 +#endif /*LV_SPRINTF_CUSTOM*/ + +#define LV_USE_USER_DATA 1 + +/*Garbage Collector settings + *Used if lvgl is bound to higher level language and the memory is managed by that language*/ +#define LV_ENABLE_GC 0 +#if LV_ENABLE_GC != 0 + #define LV_GC_INCLUDE "gc.h" /*Include Garbage Collector related things*/ +#endif /*LV_ENABLE_GC*/ + +/*===================== + * COMPILER SETTINGS + *====================*/ + +/*For big endian systems set to 1*/ +#define LV_BIG_ENDIAN_SYSTEM 0 + +/*Define a custom attribute to `lv_tick_inc` function*/ +#define LV_ATTRIBUTE_TICK_INC + +/*Define a custom attribute to `lv_timer_handler` function*/ +#define LV_ATTRIBUTE_TIMER_HANDLER + +/*Define a custom attribute to `lv_disp_flush_ready` function*/ +#define LV_ATTRIBUTE_FLUSH_READY + +/*Required alignment size for buffers*/ +#define LV_ATTRIBUTE_MEM_ALIGN_SIZE 1 + +/*Will be added where memories needs to be aligned (with -Os data might not be aligned to boundary by default). + * E.g. __attribute__((aligned(4)))*/ +#define LV_ATTRIBUTE_MEM_ALIGN + +/*Attribute to mark large constant arrays for example font's bitmaps*/ +#define LV_ATTRIBUTE_LARGE_CONST + +/*Compiler prefix for a big array declaration in RAM*/ +#define LV_ATTRIBUTE_LARGE_RAM_ARRAY + +/*Place performance critical functions into a faster memory (e.g RAM)*/ +#define LV_ATTRIBUTE_FAST_MEM + +/*Prefix variables that are used in GPU accelerated operations, often these need to be placed in RAM sections that are DMA accessible*/ +#define LV_ATTRIBUTE_DMA + +/*Export integer constant to binding. This macro is used with constants in the form of LV_ that + *should also appear on LVGL binding API such as Micropython.*/ +#define LV_EXPORT_CONST_INT(int_value) struct _silence_gcc_warning /*The default value just prevents GCC warning*/ + +/*Extend the default -32k..32k coordinate range to -4M..4M by using int32_t for coordinates instead of int16_t*/ +#define LV_USE_LARGE_COORD 0 + +/*================== + * FONT USAGE + *===================*/ + +/*Montserrat fonts with ASCII range and some symbols using bpp = 4 + *https://fonts.google.com/specimen/Montserrat*/ +#define LV_FONT_MONTSERRAT_8 0 +#define LV_FONT_MONTSERRAT_10 0 +#define LV_FONT_MONTSERRAT_12 1 +#define LV_FONT_MONTSERRAT_14 1 +#define LV_FONT_MONTSERRAT_16 1 +#define LV_FONT_MONTSERRAT_18 1 +#define LV_FONT_MONTSERRAT_20 1 +#define LV_FONT_MONTSERRAT_22 1 +#define LV_FONT_MONTSERRAT_24 1 +#define LV_FONT_MONTSERRAT_26 1 +#define LV_FONT_MONTSERRAT_28 0 +#define LV_FONT_MONTSERRAT_30 0 +#define LV_FONT_MONTSERRAT_32 1 +#define LV_FONT_MONTSERRAT_34 0 +#define LV_FONT_MONTSERRAT_36 0 +#define LV_FONT_MONTSERRAT_38 0 +#define LV_FONT_MONTSERRAT_40 1 +#define LV_FONT_MONTSERRAT_42 0 +#define LV_FONT_MONTSERRAT_44 1 +#define LV_FONT_MONTSERRAT_46 0 +#define LV_FONT_MONTSERRAT_48 1 + +/*Demonstrate special features*/ +#define LV_FONT_MONTSERRAT_12_SUBPX 0 +#define LV_FONT_MONTSERRAT_28_COMPRESSED 0 /*bpp = 3*/ +#define LV_FONT_DEJAVU_16_PERSIAN_HEBREW 0 /*Hebrew, Arabic, Persian letters and all their forms*/ +#define LV_FONT_SIMSUN_16_CJK 0 /*1000 most common CJK radicals*/ + +/*Pixel perfect monospace fonts*/ +#define LV_FONT_UNSCII_8 0 +#define LV_FONT_UNSCII_16 0 + +/*Optionally declare custom fonts here. + *You can use these fonts as default font too and they will be available globally. + *E.g. #define LV_FONT_CUSTOM_DECLARE LV_FONT_DECLARE(my_font_1) LV_FONT_DECLARE(my_font_2)*/ +#define LV_FONT_CUSTOM_DECLARE + +/*Always set a default font*/ +#define LV_FONT_DEFAULT &lv_font_montserrat_14 + +/*Enable handling large font and/or fonts with a lot of characters. + *The limit depends on the font size, font face and bpp. + *Compiler error will be triggered if a font needs it.*/ +#define LV_FONT_FMT_TXT_LARGE 0 + +/*Enables/disables support for compressed fonts.*/ +#define LV_USE_FONT_COMPRESSED 0 + +/*Enable subpixel rendering*/ +#define LV_USE_FONT_SUBPX 0 +#if LV_USE_FONT_SUBPX + /*Set the pixel order of the display. Physical order of RGB channels. Doesn't matter with "normal" fonts.*/ + #define LV_FONT_SUBPX_BGR 0 /*0: RGB; 1:BGR order*/ +#endif + +/*Enable drawing placeholders when glyph dsc is not found*/ +#define LV_USE_FONT_PLACEHOLDER 1 + +/*================= + * TEXT SETTINGS + *=================*/ + +/** + * Select a character encoding for strings. + * Your IDE or editor should have the same character encoding + * - LV_TXT_ENC_UTF8 + * - LV_TXT_ENC_ASCII + */ +#define LV_TXT_ENC LV_TXT_ENC_UTF8 + +/*Can break (wrap) texts on these chars*/ +#define LV_TXT_BREAK_CHARS " ,.;:-_" + +/*If a word is at least this long, will break wherever "prettiest" + *To disable, set to a value <= 0*/ +#define LV_TXT_LINE_BREAK_LONG_LEN 0 + +/*Minimum number of characters in a long word to put on a line before a break. + *Depends on LV_TXT_LINE_BREAK_LONG_LEN.*/ +#define LV_TXT_LINE_BREAK_LONG_PRE_MIN_LEN 3 + +/*Minimum number of characters in a long word to put on a line after a break. + *Depends on LV_TXT_LINE_BREAK_LONG_LEN.*/ +#define LV_TXT_LINE_BREAK_LONG_POST_MIN_LEN 3 + +/*The control character to use for signalling text recoloring.*/ +#define LV_TXT_COLOR_CMD "#" + +/*Support bidirectional texts. Allows mixing Left-to-Right and Right-to-Left texts. + *The direction will be processed according to the Unicode Bidirectional Algorithm: + *https://www.w3.org/International/articles/inline-bidi-markup/uba-basics*/ +#define LV_USE_BIDI 0 +#if LV_USE_BIDI + /*Set the default direction. Supported values: + *`LV_BASE_DIR_LTR` Left-to-Right + *`LV_BASE_DIR_RTL` Right-to-Left + *`LV_BASE_DIR_AUTO` detect texts base direction*/ + #define LV_BIDI_BASE_DIR_DEF LV_BASE_DIR_AUTO +#endif + +/*Enable Arabic/Persian processing + *In these languages characters should be replaced with an other form based on their position in the text*/ +#define LV_USE_ARABIC_PERSIAN_CHARS 0 + +/*================== + * WIDGET USAGE + *================*/ + +/*Documentation of the widgets: https://docs.lvgl.io/latest/en/html/widgets/index.html*/ + +#define LV_USE_ARC 0 + +#define LV_USE_BAR 0 + +#define LV_USE_BTN 1 + +#define LV_USE_BTNMATRIX 1 + +#define LV_USE_CANVAS 1 + +#define LV_USE_CHECKBOX 1 + +#define LV_USE_DROPDOWN 1 /*Requires: lv_label*/ + +#define LV_USE_IMG 1 /*Requires: lv_label*/ + +#define LV_USE_LABEL 1 +#if LV_USE_LABEL + #define LV_LABEL_TEXT_SELECTION 1 /*Enable selecting text of the label*/ + #define LV_LABEL_LONG_TXT_HINT 1 /*Store some extra info in labels to speed up drawing of very long texts*/ +#endif + +#define LV_USE_LINE 0 + +#define LV_USE_ROLLER 1 /*Requires: lv_label*/ +#if LV_USE_ROLLER + #define LV_ROLLER_INF_PAGES 7 /*Number of extra "pages" when the roller is infinite*/ +#endif + +#define LV_USE_SLIDER 0 /*Requires: lv_bar*/ + +#define LV_USE_SWITCH 0 + +#define LV_USE_TEXTAREA 1 /*Requires: lv_label*/ +#if LV_USE_TEXTAREA != 0 + #define LV_TEXTAREA_DEF_PWD_SHOW_TIME 1500 /*ms*/ +#endif + +#define LV_USE_TABLE 0 + +/*================== + * EXTRA COMPONENTS + *==================*/ + +/*----------- + * Widgets + *----------*/ +#define LV_USE_ANIMIMG 0 + +#define LV_USE_CALENDAR 0 +#if LV_USE_CALENDAR + #define LV_CALENDAR_WEEK_STARTS_MONDAY 0 + #if LV_CALENDAR_WEEK_STARTS_MONDAY + #define LV_CALENDAR_DEFAULT_DAY_NAMES {"Mo", "Tu", "We", "Th", "Fr", "Sa", "Su"} + #else + #define LV_CALENDAR_DEFAULT_DAY_NAMES {"Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"} + #endif + + #define LV_CALENDAR_DEFAULT_MONTH_NAMES {"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"} + #define LV_USE_CALENDAR_HEADER_ARROW 1 + #define LV_USE_CALENDAR_HEADER_DROPDOWN 1 +#endif /*LV_USE_CALENDAR*/ + +#define LV_USE_CHART 0 + +#define LV_USE_COLORWHEEL 0 + +#define LV_USE_IMGBTN 1 + +#define LV_USE_KEYBOARD 1 + +#define LV_USE_LED 0 + +#define LV_USE_LIST 1 + +#define LV_USE_MENU 1 + +#define LV_USE_METER 0 + +#define LV_USE_MSGBOX 1 + +#define LV_USE_SPAN 1 +#if LV_USE_SPAN + /*A line text can contain maximum num of span descriptor */ + #define LV_SPAN_SNIPPET_STACK_SIZE 64 +#endif + +#define LV_USE_SPINBOX 0 + +#define LV_USE_SPINNER 0 + +#define LV_USE_TABVIEW 1 + +#define LV_USE_TILEVIEW 0 + +#define LV_USE_WIN 0 + +/*----------- + * Themes + *----------*/ + +/*A simple, impressive and very complete theme*/ +#define LV_USE_THEME_DEFAULT 1 +#if LV_USE_THEME_DEFAULT + + /*0: Light mode; 1: Dark mode*/ + #define LV_THEME_DEFAULT_DARK 0 + + /*1: Enable grow on press*/ + #define LV_THEME_DEFAULT_GROW 1 + + /*Default transition time in [ms]*/ + #define LV_THEME_DEFAULT_TRANSITION_TIME 80 +#endif /*LV_USE_THEME_DEFAULT*/ + +/*A very simple theme that is a good starting point for a custom theme*/ +#define LV_USE_THEME_BASIC 1 + +/*A theme designed for monochrome displays*/ +#define LV_USE_THEME_MONO 1 + +/*----------- + * Layouts + *----------*/ + +/*A layout similar to Flexbox in CSS.*/ +#define LV_USE_FLEX 1 + +/*A layout similar to Grid in CSS.*/ +#define LV_USE_GRID 1 + +/*--------------------- + * 3rd party libraries + *--------------------*/ + +/*File system interfaces for common APIs */ + +/*API for fopen, fread, etc*/ +#define LV_USE_FS_STDIO 0 +#if LV_USE_FS_STDIO + #define LV_FS_STDIO_LETTER '\0' /*Set an upper cased letter on which the drive will accessible (e.g. 'A')*/ + #define LV_FS_STDIO_PATH "" /*Set the working directory. File/directory paths will be appended to it.*/ + #define LV_FS_STDIO_CACHE_SIZE 0 /*>0 to cache this number of bytes in lv_fs_read()*/ +#endif + +/*API for open, read, etc*/ +#define LV_USE_FS_POSIX 0 +#if LV_USE_FS_POSIX + #define LV_FS_POSIX_LETTER '\0' /*Set an upper cased letter on which the drive will accessible (e.g. 'A')*/ + #define LV_FS_POSIX_PATH "" /*Set the working directory. File/directory paths will be appended to it.*/ + #define LV_FS_POSIX_CACHE_SIZE 0 /*>0 to cache this number of bytes in lv_fs_read()*/ +#endif + +/*API for CreateFile, ReadFile, etc*/ +#define LV_USE_FS_WIN32 0 +#if LV_USE_FS_WIN32 + #define LV_FS_WIN32_LETTER '\0' /*Set an upper cased letter on which the drive will accessible (e.g. 'A')*/ + #define LV_FS_WIN32_PATH "" /*Set the working directory. File/directory paths will be appended to it.*/ + #define LV_FS_WIN32_CACHE_SIZE 0 /*>0 to cache this number of bytes in lv_fs_read()*/ +#endif + +/*API for FATFS (needs to be added separately). Uses f_open, f_read, etc*/ +#define LV_USE_FS_FATFS 0 +#if LV_USE_FS_FATFS + #define LV_FS_FATFS_LETTER '\0' /*Set an upper cased letter on which the drive will accessible (e.g. 'A')*/ + #define LV_FS_FATFS_CACHE_SIZE 0 /*>0 to cache this number of bytes in lv_fs_read()*/ +#endif + +/*API for LittleFS (library needs to be added separately). Uses lfs_file_open, lfs_file_read, etc*/ +#define LV_USE_FS_LITTLEFS 0 +#if LV_USE_FS_LITTLEFS + #define LV_FS_LITTLEFS_LETTER '\0' /*Set an upper cased letter on which the drive will accessible (e.g. 'A')*/ + #define LV_FS_LITTLEFS_CACHE_SIZE 0 /*>0 to cache this number of bytes in lv_fs_read()*/ +#endif + +/*PNG decoder library*/ +#define LV_USE_PNG 0 + +/*BMP decoder library*/ +#define LV_USE_BMP 0 + +/* JPG + split JPG decoder library. + * Split JPG is a custom format optimized for embedded systems. */ +#define LV_USE_SJPG 0 + +/*GIF decoder library*/ +#define LV_USE_GIF 0 + +/*QR code library*/ +#define LV_USE_QRCODE 0 + +/*FreeType library*/ +#define LV_USE_FREETYPE 0 +#if LV_USE_FREETYPE + /*Memory used by FreeType to cache characters [bytes] (-1: no caching)*/ + #define LV_FREETYPE_CACHE_SIZE (16 * 1024) + #if LV_FREETYPE_CACHE_SIZE >= 0 + /* 1: bitmap cache use the sbit cache, 0:bitmap cache use the image cache. */ + /* sbit cache:it is much more memory efficient for small bitmaps(font size < 256) */ + /* if font size >= 256, must be configured as image cache */ + #define LV_FREETYPE_SBIT_CACHE 0 + /* Maximum number of opened FT_Face/FT_Size objects managed by this cache instance. */ + /* (0:use system defaults) */ + #define LV_FREETYPE_CACHE_FT_FACES 0 + #define LV_FREETYPE_CACHE_FT_SIZES 0 + #endif +#endif + +/*Tiny TTF library*/ +#define LV_USE_TINY_TTF 0 +#if LV_USE_TINY_TTF + /*Load TTF data from files*/ + #define LV_TINY_TTF_FILE_SUPPORT 0 +#endif + +/*Rlottie library*/ +#define LV_USE_RLOTTIE 0 + +/*FFmpeg library for image decoding and playing videos + *Supports all major image formats so do not enable other image decoder with it*/ +#define LV_USE_FFMPEG 0 +#if LV_USE_FFMPEG + /*Dump input information to stderr*/ + #define LV_FFMPEG_DUMP_FORMAT 0 +#endif + +/*----------- + * Others + *----------*/ + +/*1: Enable API to take snapshot for object*/ +#define LV_USE_SNAPSHOT 0 + +/*1: Enable Monkey test*/ +#define LV_USE_MONKEY 0 + +/*1: Enable grid navigation*/ +#define LV_USE_GRIDNAV 0 + +/*1: Enable lv_obj fragment*/ +#define LV_USE_FRAGMENT 0 + +/*1: Support using images as font in label or span widgets */ +#define LV_USE_IMGFONT 0 + +/*1: Enable a published subscriber based messaging system */ +#define LV_USE_MSG 0 + +/*1: Enable Pinyin input method*/ +/*Requires: lv_keyboard*/ +#define LV_USE_IME_PINYIN 0 +#if LV_USE_IME_PINYIN + /*1: Use default thesaurus*/ + /*If you do not use the default thesaurus, be sure to use `lv_ime_pinyin` after setting the thesauruss*/ + #define LV_IME_PINYIN_USE_DEFAULT_DICT 1 + /*Set the maximum number of candidate panels that can be displayed*/ + /*This needs to be adjusted according to the size of the screen*/ + #define LV_IME_PINYIN_CAND_TEXT_NUM 6 + + /*Use 9 key input(k9)*/ + #define LV_IME_PINYIN_USE_K9_MODE 1 + #if LV_IME_PINYIN_USE_K9_MODE == 1 + #define LV_IME_PINYIN_K9_CAND_TEXT_NUM 3 + #endif // LV_IME_PINYIN_USE_K9_MODE +#endif + +/*================== +* EXAMPLES +*==================*/ + +/*Enable the examples to be built with the library*/ +#define LV_BUILD_EXAMPLES 0 + +/*=================== + * DEMO USAGE + ====================*/ + +/*Show some widget. It might be required to increase `LV_MEM_SIZE` */ +#define LV_USE_DEMO_WIDGETS 0 +#if LV_USE_DEMO_WIDGETS +#define LV_DEMO_WIDGETS_SLIDESHOW 0 +#endif + +/*Demonstrate the usage of encoder and keyboard*/ +#define LV_USE_DEMO_KEYPAD_AND_ENCODER 0 + +/*Benchmark your system*/ +#define LV_USE_DEMO_BENCHMARK 0 +#if LV_USE_DEMO_BENCHMARK +/*Use RGB565A8 images with 16 bit color depth instead of ARGB8565*/ +#define LV_DEMO_BENCHMARK_RGB565A8 0 +#endif + +/*Stress test for LVGL*/ +#define LV_USE_DEMO_STRESS 0 + +/*Music player demo*/ +#define LV_USE_DEMO_MUSIC 0 +#if LV_USE_DEMO_MUSIC + #define LV_DEMO_MUSIC_SQUARE 0 + #define LV_DEMO_MUSIC_LANDSCAPE 0 + #define LV_DEMO_MUSIC_ROUND 0 + #define LV_DEMO_MUSIC_LARGE 0 + #define LV_DEMO_MUSIC_AUTO_PLAY 0 +#endif + +/*--END OF LV_CONF_H--*/ + +#endif /*LV_CONF_H*/ + +#endif /*End of "Content enable"*/ diff --git a/partition-table-8MB.csv b/partition-table-8MB.csv new file mode 100644 index 0000000000..0bfbc22ba1 --- /dev/null +++ b/partition-table-8MB.csv @@ -0,0 +1,7 @@ +# This is a layout for 8MB of flash for MUI devices +# Name, Type, SubType, Offset, Size, Flags +nvs, data, nvs, 0x9000, 0x5000, +otadata, data, ota, 0xe000, 0x2000, +app0, app, ota_0, 0x10000, 0x5C0000, +flashApp, app, ota_1, 0x5D0000,0x0A0000, +spiffs, data, spiffs, 0x670000,0x180000 \ No newline at end of file diff --git a/src/fonts/fonts.h b/src/fonts/fonts.h new file mode 100644 index 0000000000..319e1c826c --- /dev/null +++ b/src/fonts/fonts.h @@ -0,0 +1,25 @@ +extern const lv_font_t lv_font_arial_8; +extern const lv_font_t lv_font_arial_10; +extern const lv_font_t lv_font_arial_12; +extern const lv_font_t lv_font_arial_14; +extern const lv_font_t lv_font_arial_16; +extern const lv_font_t lv_font_arial_18; +extern const lv_font_t lv_font_arial_20; +extern const lv_font_t lv_font_arial_22; +extern const lv_font_t lv_font_arial_24; +extern const lv_font_t lv_font_arial_26; +extern const lv_font_t lv_font_arial_28; +extern const lv_font_t lv_font_arial_30; +extern const lv_font_t lv_font_arial_32; +extern const lv_font_t lv_font_arial_34; +extern const lv_font_t lv_font_arial_36; +extern const lv_font_t lv_font_arial_38; +extern const lv_font_t lv_font_arial_40; +extern const lv_font_t lv_font_arial_42; +extern const lv_font_t lv_font_arial_44; +extern const lv_font_t lv_font_arial_46; +extern const lv_font_t lv_font_arial_48; +extern const lv_font_t lv_font_arial_50; +extern const lv_font_t lv_font_arial_58; +extern const lv_font_t lv_font_arial_66; +extern const lv_font_t lv_font_arial_74; diff --git a/src/fonts/lv_font_arial_10.c b/src/fonts/lv_font_arial_10.c new file mode 100644 index 0000000000..1c447990dd --- /dev/null +++ b/src/fonts/lv_font_arial_10.c @@ -0,0 +1,1244 @@ +/******************************************************************************* + * Size: 10 px + * Bpp: 4 + * Opts: --bpp 4 --size 10 --no-compress --stride 1 --align 1 --font Arial Greek Regular.ttf --range 32-127,160-255,880-1023 --format lvgl -o lv_font_arial_10.c + ******************************************************************************/ + +#ifdef __has_include + #if __has_include("lvgl.h") + #ifndef LV_LVGL_H_INCLUDE_SIMPLE + #define LV_LVGL_H_INCLUDE_SIMPLE + #endif + #endif +#endif + +#ifdef LV_LVGL_H_INCLUDE_SIMPLE + #include "lvgl.h" +#else + #include "lvgl/lvgl.h" +#endif + + + +#ifndef LV_FONT_ARIAL_10 +#define LV_FONT_ARIAL_10 1 +#endif + +#if LV_FONT_ARIAL_10 + +/*----------------- + * BITMAPS + *----------------*/ + +/*Store the image of the glyphs*/ +static LV_ATTRIBUTE_LARGE_CONST const uint8_t glyph_bitmap[] = { + /* U+0020 " " */ + + /* U+0021 "!" */ + 0x2f, 0x2e, 0x1d, 0xc, 0xa, 0x0, 0x1d, + + /* U+0022 "\"" */ + 0x87, 0xe1, 0x76, 0xd0, 0x21, 0x30, + + /* U+0023 "#" */ + 0x1, 0xa0, 0xb0, 0x4, 0x60, 0xb0, 0x9d, 0xbc, + 0xd4, 0xb, 0x7, 0x40, 0x9e, 0xbe, 0xb4, 0x28, + 0xb, 0x0, 0x65, 0x1a, 0x0, + + /* U+0024 "$" */ + 0x0, 0x40, 0x0, 0x1c, 0xdc, 0x60, 0x67, 0x71, + 0x80, 0x4c, 0x90, 0x0, 0x4, 0xcd, 0x50, 0x0, + 0x71, 0xe0, 0x87, 0x70, 0xd0, 0x1b, 0xdc, 0x50, + 0x0, 0x70, 0x0, + + /* U+0025 "%" */ + 0x1a, 0xa3, 0x3, 0x70, 0x5, 0x62, 0x90, 0xa0, + 0x0, 0x47, 0x38, 0x55, 0x0, 0x0, 0x89, 0x2a, + 0x29, 0x70, 0x0, 0x7, 0x4a, 0x18, 0x30, 0x1, + 0xa0, 0xb0, 0x83, 0x0, 0x92, 0x4, 0xaa, 0x0, + + /* U+0026 "&" */ + 0x3, 0xcc, 0x50, 0x0, 0x95, 0x3b, 0x0, 0x3, + 0xdc, 0x40, 0x0, 0x9c, 0xc0, 0x30, 0x69, 0x9, + 0xcb, 0x7, 0x80, 0x1f, 0x90, 0xa, 0xcc, 0x5c, + 0x30, 0x0, 0x0, 0x0, + + /* U+0027 "'" */ + 0x87, 0x76, 0x21, + + /* U+0028 "(" */ + 0x1, 0x90, 0x92, 0xc, 0x4, 0x90, 0x58, 0x4, + 0x90, 0xc, 0x0, 0x92, 0x1, 0x90, + + /* U+0029 ")" */ + 0x55, 0x0, 0xb0, 0x7, 0x50, 0x49, 0x3, 0xb0, + 0x49, 0x7, 0x50, 0xb0, 0x55, 0x0, + + /* U+002A "*" */ + 0x16, 0x41, 0x4c, 0xc3, 0x17, 0x80, + + /* U+002B "+" */ + 0x0, 0x32, 0x0, 0x0, 0x85, 0x0, 0x5c, 0xed, + 0xc3, 0x0, 0x85, 0x0, 0x0, 0x85, 0x0, + + /* U+002C "," */ + 0x1d, 0x8, 0x1, + + /* U+002D "-" */ + 0x9d, 0xd0, + + /* U+002E "." */ + 0x1d, + + /* U+002F "/" */ + 0x1, 0x90, 0x55, 0xa, 0x0, 0xa0, 0x47, 0x8, + 0x20, 0xb0, 0x0, + + /* U+0030 "0" */ + 0x8, 0xbb, 0x20, 0x3a, 0x2, 0xc0, 0x76, 0x0, + 0xd0, 0x85, 0x0, 0xd1, 0x76, 0x0, 0xd0, 0x3a, + 0x2, 0xc0, 0x8, 0xbb, 0x30, + + /* U+0031 "1" */ + 0x3, 0xb7, 0xdc, 0x52, 0xc0, 0x2c, 0x2, 0xc0, + 0x2c, 0x2, 0xc0, + + /* U+0032 "2" */ + 0xa, 0xbb, 0x40, 0x68, 0x0, 0xe0, 0x0, 0x1, + 0xe0, 0x0, 0xc, 0x50, 0x1, 0xc5, 0x0, 0x1d, + 0x30, 0x0, 0x9e, 0xcc, 0xc0, + + /* U+0033 "3" */ + 0x9, 0xbb, 0x20, 0x59, 0x3, 0xa0, 0x0, 0x5, + 0x90, 0x0, 0x8e, 0x40, 0x0, 0x1, 0xe0, 0x57, + 0x0, 0xe0, 0xa, 0xbc, 0x50, + + /* U+0034 "4" */ + 0x0, 0x1e, 0x20, 0x0, 0xbd, 0x20, 0x9, 0x4c, + 0x20, 0x57, 0xc, 0x20, 0xbc, 0xcf, 0xc1, 0x0, + 0xc, 0x20, 0x0, 0xc, 0x20, + + /* U+0035 "5" */ + 0xc, 0xcc, 0xa0, 0xd, 0x0, 0x0, 0x3d, 0xbb, + 0x30, 0x26, 0x2, 0xe0, 0x0, 0x0, 0xc2, 0x68, + 0x1, 0xd0, 0xa, 0xbb, 0x30, + + /* U+0036 "6" */ + 0x6, 0xbc, 0x60, 0x3a, 0x0, 0x70, 0x78, 0xab, + 0x30, 0x9b, 0x2, 0xd0, 0x87, 0x0, 0xc1, 0x4b, + 0x0, 0xd0, 0x8, 0xbb, 0x40, + + /* U+0037 "7" */ + 0x6c, 0xcc, 0xf1, 0x0, 0x8, 0x70, 0x0, 0x2d, + 0x0, 0x0, 0xa5, 0x0, 0x0, 0xe0, 0x0, 0x4, + 0xa0, 0x0, 0x7, 0x70, 0x0, + + /* U+0038 "8" */ + 0x9, 0xbb, 0x30, 0x3b, 0x2, 0xb0, 0x1b, 0x3, + 0xb0, 0x1c, 0xce, 0x40, 0x88, 0x1, 0xd0, 0x77, + 0x0, 0xd0, 0xa, 0xab, 0x50, + + /* U+0039 "9" */ + 0x9, 0xbb, 0x30, 0x5a, 0x1, 0xd0, 0x86, 0x0, + 0xd1, 0x5a, 0x2, 0xf2, 0x8, 0xb8, 0xc0, 0x25, + 0x2, 0xc0, 0xb, 0xbb, 0x20, + + /* U+003A ":" */ + 0x1d, 0x0, 0x0, 0x0, 0x1d, + + /* U+003B ";" */ + 0x1d, 0x0, 0x0, 0x0, 0x1d, 0x8, 0x1, + + /* U+003C "<" */ + 0x0, 0x0, 0x42, 0x1, 0x8c, 0x81, 0x5e, 0x50, + 0x0, 0x16, 0xc9, 0x20, 0x0, 0x3, 0xa3, + + /* U+003D "=" */ + 0x5c, 0xcc, 0xc3, 0x0, 0x0, 0x0, 0x5c, 0xcc, + 0xc3, + + /* U+003E ">" */ + 0x33, 0x0, 0x0, 0x29, 0xc7, 0x10, 0x0, 0x6, + 0xe3, 0x3, 0xab, 0x50, 0x59, 0x20, 0x0, + + /* U+003F "?" */ + 0xa, 0xbc, 0x50, 0x69, 0x0, 0xe0, 0x0, 0x2, + 0xd0, 0x0, 0x1c, 0x30, 0x0, 0x95, 0x0, 0x0, + 0x30, 0x0, 0x0, 0xb3, 0x0, + + /* U+0040 "@" */ + 0x0, 0x2a, 0xaa, 0xb8, 0x0, 0x3, 0xb1, 0x0, + 0x5, 0xb0, 0xb, 0x5, 0xba, 0xa5, 0x65, 0x47, + 0x2c, 0x0, 0xe2, 0x28, 0x65, 0x76, 0x0, 0xd0, + 0x56, 0x56, 0x77, 0x6, 0xb1, 0xb0, 0x1b, 0x1c, + 0xb8, 0xeb, 0x31, 0x7, 0x90, 0x0, 0x1, 0xa5, + 0x0, 0x4b, 0xba, 0xaa, 0x30, + + /* U+0041 "A" */ + 0x0, 0x7e, 0x0, 0x0, 0xc, 0x86, 0x0, 0x3, + 0xa2, 0xc0, 0x0, 0xa4, 0xc, 0x30, 0xe, 0xbb, + 0xda, 0x6, 0x80, 0x0, 0xe1, 0xc2, 0x0, 0x9, + 0x70, + + /* U+0042 "B" */ + 0x4e, 0xcc, 0xc3, 0x4, 0xb0, 0x4, 0xb0, 0x4b, + 0x0, 0x59, 0x4, 0xec, 0xdf, 0x40, 0x4b, 0x0, + 0x2e, 0x4, 0xb0, 0x1, 0xe0, 0x4e, 0xcc, 0xd6, + 0x0, + + /* U+0043 "C" */ + 0x2, 0xac, 0xc8, 0x0, 0xd3, 0x0, 0x97, 0x5a, + 0x0, 0x0, 0x7, 0x80, 0x0, 0x0, 0x5a, 0x0, + 0x1, 0x40, 0xd3, 0x0, 0x97, 0x3, 0xcc, 0xc8, + 0x0, + + /* U+0044 "D" */ + 0x3f, 0xcc, 0xd6, 0x3, 0xb0, 0x0, 0xc3, 0x3b, + 0x0, 0x6, 0x93, 0xb0, 0x0, 0x4a, 0x3b, 0x0, + 0x6, 0x93, 0xb0, 0x0, 0xc3, 0x3f, 0xcc, 0xd6, + 0x0, + + /* U+0045 "E" */ + 0x3f, 0xcc, 0xcc, 0x3, 0xb0, 0x0, 0x0, 0x3b, + 0x0, 0x0, 0x3, 0xfc, 0xcc, 0x80, 0x3b, 0x0, + 0x0, 0x3, 0xb0, 0x0, 0x0, 0x3f, 0xcc, 0xcc, + 0x10, + + /* U+0046 "F" */ + 0x3f, 0xcc, 0xc7, 0x3c, 0x0, 0x0, 0x3c, 0x0, + 0x0, 0x3f, 0xcc, 0xc1, 0x3c, 0x0, 0x0, 0x3c, + 0x0, 0x0, 0x3c, 0x0, 0x0, + + /* U+0047 "G" */ + 0x1, 0xac, 0xcb, 0x20, 0xd, 0x40, 0x3, 0xc0, + 0x4a, 0x0, 0x0, 0x0, 0x78, 0x0, 0xbc, 0xd2, + 0x5a, 0x0, 0x0, 0xc2, 0xd, 0x50, 0x2, 0xe2, + 0x1, 0xac, 0xdc, 0x40, + + /* U+0048 "H" */ + 0x3c, 0x0, 0x8, 0x63, 0xc0, 0x0, 0x86, 0x3c, + 0x0, 0x8, 0x63, 0xfc, 0xcc, 0xe6, 0x3c, 0x0, + 0x8, 0x63, 0xc0, 0x0, 0x86, 0x3c, 0x0, 0x8, + 0x60, + + /* U+0049 "I" */ + 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, + + /* U+004A "J" */ + 0x0, 0xb, 0x30, 0x0, 0xb3, 0x0, 0xb, 0x30, + 0x0, 0xb3, 0x10, 0xb, 0x3a, 0x40, 0xd1, 0x3c, + 0xd8, 0x0, + + /* U+004B "K" */ + 0x4b, 0x0, 0x4d, 0x24, 0xb0, 0x5d, 0x10, 0x4b, + 0x5c, 0x10, 0x4, 0xec, 0xd1, 0x0, 0x4d, 0x6, + 0xc0, 0x4, 0xb0, 0xa, 0x80, 0x4b, 0x0, 0x1e, + 0x40, + + /* U+004C "L" */ + 0x4b, 0x0, 0x0, 0x4b, 0x0, 0x0, 0x4b, 0x0, + 0x0, 0x4b, 0x0, 0x0, 0x4b, 0x0, 0x0, 0x4b, + 0x0, 0x0, 0x4f, 0xcc, 0xc2, + + /* U+004D "M" */ + 0x4f, 0x50, 0x0, 0xd9, 0x4d, 0xa0, 0x3, 0xd9, + 0x4a, 0xc0, 0x9, 0x89, 0x4a, 0x75, 0xb, 0x59, + 0x4a, 0x2b, 0x47, 0x59, 0x4a, 0xc, 0xb2, 0x59, + 0x4a, 0x7, 0xc0, 0x59, + + /* U+004E "N" */ + 0x3f, 0x20, 0x7, 0x73, 0xec, 0x0, 0x77, 0x3b, + 0x97, 0x7, 0x73, 0xb0, 0xd2, 0x77, 0x3b, 0x4, + 0xc8, 0x73, 0xb0, 0x9, 0xe7, 0x3b, 0x0, 0xd, + 0x70, + + /* U+004F "O" */ + 0x2, 0xac, 0xc9, 0x0, 0xd, 0x30, 0x6, 0xb0, + 0x5a, 0x0, 0x0, 0xd2, 0x77, 0x0, 0x0, 0xb4, + 0x69, 0x0, 0x0, 0xd2, 0xd, 0x30, 0x6, 0xb0, + 0x2, 0xbc, 0xc9, 0x0, + + /* U+0050 "P" */ + 0x3f, 0xcc, 0xd8, 0x3, 0xb0, 0x0, 0xe2, 0x3b, + 0x0, 0x1e, 0x13, 0xfc, 0xcc, 0x50, 0x3b, 0x0, + 0x0, 0x3, 0xb0, 0x0, 0x0, 0x3b, 0x0, 0x0, + 0x0, + + /* U+0051 "Q" */ + 0x2, 0xac, 0xc9, 0x0, 0xd, 0x30, 0x6, 0xb0, + 0x59, 0x0, 0x0, 0xd2, 0x77, 0x0, 0x0, 0xb4, + 0x59, 0x0, 0x0, 0xd2, 0xd, 0x30, 0xb9, 0xb0, + 0x2, 0xbc, 0xdb, 0xb2, 0x0, 0x0, 0x0, 0x21, + + /* U+0052 "R" */ + 0x3e, 0xbb, 0xcb, 0x10, 0x3c, 0x0, 0x9, 0x70, + 0x3c, 0x0, 0xa, 0x60, 0x3f, 0xcd, 0xd7, 0x0, + 0x3c, 0x0, 0xc5, 0x0, 0x3c, 0x0, 0x1e, 0x20, + 0x3c, 0x0, 0x6, 0xc0, + + /* U+0053 "S" */ + 0x7, 0xcc, 0xb2, 0x3, 0xc0, 0x3, 0xc0, 0x2d, + 0x51, 0x0, 0x0, 0x29, 0xdd, 0x40, 0x22, 0x0, + 0x3e, 0x5, 0xb0, 0x1, 0xd0, 0x7, 0xdc, 0xc4, + 0x0, + + /* U+0054 "T" */ + 0x9c, 0xee, 0xcb, 0x0, 0x68, 0x0, 0x0, 0x68, + 0x0, 0x0, 0x68, 0x0, 0x0, 0x68, 0x0, 0x0, + 0x68, 0x0, 0x0, 0x68, 0x0, + + /* U+0055 "U" */ + 0x3c, 0x0, 0x8, 0x63, 0xc0, 0x0, 0x86, 0x3c, + 0x0, 0x8, 0x63, 0xc0, 0x0, 0x86, 0x2c, 0x0, + 0x9, 0x60, 0xd2, 0x0, 0xd2, 0x4, 0xcc, 0xd6, + 0x0, + + /* U+0056 "V" */ + 0xc4, 0x0, 0x9, 0x65, 0xa0, 0x0, 0xd0, 0xe, + 0x0, 0x59, 0x0, 0x95, 0xb, 0x30, 0x2, 0xb1, + 0xc0, 0x0, 0xc, 0x86, 0x0, 0x0, 0x5e, 0x0, + 0x0, + + /* U+0057 "W" */ + 0xc3, 0x0, 0xf7, 0x0, 0xc2, 0x76, 0x4, 0xab, + 0x0, 0xd0, 0x3a, 0x9, 0x3d, 0x4, 0x90, 0xd, + 0xc, 0x8, 0x48, 0x50, 0xa, 0x4a, 0x4, 0x8c, + 0x0, 0x6, 0xc6, 0x0, 0xbb, 0x0, 0x2, 0xf1, + 0x0, 0xb7, 0x0, + + /* U+0058 "X" */ + 0x4d, 0x0, 0x1d, 0x10, 0x89, 0xc, 0x40, 0x0, + 0xcb, 0x70, 0x0, 0x6, 0xf1, 0x0, 0x1, 0xd7, + 0xc0, 0x0, 0xc4, 0xa, 0x80, 0x98, 0x0, 0xd, + 0x40, + + /* U+0059 "Y" */ + 0xa8, 0x0, 0xd, 0x30, 0xd3, 0x8, 0x80, 0x4, + 0xd3, 0xc0, 0x0, 0x9, 0xe2, 0x0, 0x0, 0x3b, + 0x0, 0x0, 0x3, 0xb0, 0x0, 0x0, 0x3b, 0x0, + 0x0, + + /* U+005A "Z" */ + 0x5c, 0xcc, 0xeb, 0x0, 0x2, 0xd2, 0x0, 0xd, + 0x50, 0x0, 0xa8, 0x0, 0x7, 0xb0, 0x0, 0x4d, + 0x0, 0x0, 0xcd, 0xcc, 0xca, + + /* U+005B "[" */ + 0x5d, 0x65, 0x80, 0x58, 0x5, 0x80, 0x58, 0x5, + 0x80, 0x58, 0x5, 0x80, 0x5d, 0x60, + + /* U+005C "\\" */ + 0xb0, 0x8, 0x20, 0x47, 0x0, 0xa0, 0xa, 0x0, + 0x55, 0x1, 0x90, + + /* U+005D "]" */ + 0x9e, 0x10, 0xc1, 0xc, 0x10, 0xc1, 0xc, 0x10, + 0xc1, 0xc, 0x10, 0xc1, 0x9e, 0x10, + + /* U+005E "^" */ + 0x1, 0x60, 0x0, 0x8d, 0x30, 0xc, 0x2a, 0x7, + 0x60, 0xa2, + + /* U+005F "_" */ + 0x9, 0x99, 0x99, 0x50, + + /* U+0060 "`" */ + 0x0, 0x2, 0xc0, 0x2, 0x0, + + /* U+0061 "a" */ + 0x1a, 0xac, 0x60, 0x34, 0x1, 0xd0, 0x1a, 0xa9, + 0xe0, 0x96, 0x3, 0xe0, 0x4c, 0xaa, 0xd0, + + /* U+0062 "b" */ + 0x58, 0x0, 0x0, 0x58, 0x0, 0x0, 0x5c, 0xac, + 0x50, 0x5b, 0x0, 0xd0, 0x58, 0x0, 0xc2, 0x5a, + 0x0, 0xd0, 0x5c, 0x9a, 0x40, + + /* U+0063 "c" */ + 0xa, 0xbc, 0x46, 0x80, 0x26, 0x95, 0x0, 0x6, + 0x80, 0x1a, 0xa, 0xbb, 0x30, + + /* U+0064 "d" */ + 0x0, 0x0, 0xd0, 0x0, 0xd, 0xa, 0xb9, 0xd7, + 0x70, 0x3d, 0x94, 0x0, 0xd6, 0x80, 0x2d, 0xa, + 0xba, 0xd0, + + /* U+0065 "e" */ + 0x9, 0xbb, 0x40, 0x68, 0x0, 0xd0, 0x9c, 0xbb, + 0xc1, 0x68, 0x0, 0x80, 0xa, 0xbc, 0x60, + + /* U+0066 "f" */ + 0xb, 0xc0, 0x2c, 0x0, 0xae, 0x70, 0x2b, 0x0, + 0x2b, 0x0, 0x2b, 0x0, 0x2b, 0x0, + + /* U+0067 "g" */ + 0xa, 0xba, 0xd7, 0x70, 0x2e, 0x94, 0x0, 0xd7, + 0x70, 0x2e, 0xa, 0xba, 0xe3, 0x30, 0x2c, 0x1b, + 0xab, 0x30, + + /* U+0068 "h" */ + 0x58, 0x0, 0x5, 0x80, 0x0, 0x5c, 0xac, 0x65, + 0xb0, 0x1d, 0x58, 0x0, 0xe5, 0x80, 0xe, 0x58, + 0x0, 0xe0, + + /* U+0069 "i" */ + 0x58, 0x0, 0x58, 0x58, 0x58, 0x58, 0x58, + + /* U+006A "j" */ + 0x5, 0x80, 0x0, 0x5, 0x80, 0x58, 0x5, 0x80, + 0x58, 0x5, 0x80, 0x58, 0x4d, 0x40, + + /* U+006B "k" */ + 0x58, 0x0, 0x5, 0x80, 0x0, 0x58, 0x1c, 0x45, + 0xac, 0x30, 0x5e, 0xc3, 0x5, 0x82, 0xd0, 0x58, + 0x7, 0x90, + + /* U+006C "l" */ + 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, + + /* U+006D "m" */ + 0x5b, 0x9c, 0x79, 0xc4, 0x5a, 0x4, 0xb0, 0x3a, + 0x58, 0x4, 0x90, 0x3b, 0x58, 0x4, 0x90, 0x3b, + 0x58, 0x4, 0x90, 0x3b, + + /* U+006E "n" */ + 0x5b, 0x9b, 0x65, 0xb0, 0xd, 0x59, 0x0, 0xe5, + 0x90, 0xe, 0x59, 0x0, 0xe0, + + /* U+006F "o" */ + 0xa, 0xbb, 0x40, 0x77, 0x0, 0xd0, 0x94, 0x0, + 0xb2, 0x78, 0x0, 0xd0, 0xa, 0xbc, 0x50, + + /* U+0070 "p" */ + 0x5c, 0x9a, 0x50, 0x5a, 0x0, 0xd0, 0x57, 0x0, + 0xc2, 0x5b, 0x0, 0xd0, 0x5c, 0xbc, 0x40, 0x59, + 0x0, 0x0, 0x59, 0x0, 0x0, + + /* U+0071 "q" */ + 0xa, 0xa9, 0xc7, 0x70, 0x2d, 0x94, 0x0, 0xd6, + 0x80, 0x2d, 0xa, 0xba, 0xd0, 0x0, 0xd, 0x0, + 0x0, 0xd0, + + /* U+0072 "r" */ + 0x5b, 0xc4, 0x5a, 0x0, 0x58, 0x0, 0x58, 0x0, + 0x58, 0x0, + + /* U+0073 "s" */ + 0x2b, 0xbb, 0x17, 0x80, 0x32, 0x8, 0xcb, 0x25, + 0x30, 0x68, 0x2b, 0xab, 0x20, + + /* U+0074 "t" */ + 0x5, 0x3, 0xb0, 0x9e, 0x53, 0xb0, 0x3b, 0x2, + 0xb0, 0x1d, 0x70, + + /* U+0075 "u" */ + 0x58, 0x0, 0xd5, 0x80, 0xd, 0x58, 0x0, 0xd4, + 0x90, 0x3d, 0xb, 0xb9, 0xc0, + + /* U+0076 "v" */ + 0xa3, 0x3, 0xb4, 0x90, 0x94, 0xd, 0x1d, 0x0, + 0x7a, 0x80, 0x1, 0xf2, 0x0, + + /* U+0077 "w" */ + 0xc1, 0xf, 0x30, 0xc0, 0x76, 0x3d, 0x72, 0xa0, + 0x2a, 0x85, 0xb7, 0x50, 0xc, 0xc0, 0xcc, 0x0, + 0x8, 0xa0, 0x8b, 0x0, + + /* U+0078 "x" */ + 0x6a, 0xa, 0x60, 0xba, 0xa0, 0x3, 0xf3, 0x0, + 0xc6, 0xc0, 0x87, 0x8, 0x80, + + /* U+0079 "y" */ + 0xa4, 0x2, 0xb4, 0xa0, 0x85, 0xd, 0x1d, 0x0, + 0x7a, 0x80, 0x1, 0xf2, 0x0, 0x1b, 0x0, 0x5d, + 0x30, 0x0, + + /* U+007A "z" */ + 0x6a, 0xae, 0x80, 0x4, 0xb0, 0x3, 0xc1, 0x2, + 0xd2, 0x0, 0xbd, 0xbb, 0x80, + + /* U+007B "{" */ + 0x5, 0xc1, 0xa, 0x20, 0xb, 0x10, 0xc, 0x0, + 0xa7, 0x0, 0xc, 0x0, 0xb, 0x10, 0xa, 0x20, + 0x5, 0xc1, + + /* U+007C "|" */ + 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, + 0x1b, + + /* U+007D "}" */ + 0x9a, 0x0, 0xc, 0x0, 0xc, 0x0, 0xa, 0x30, + 0x2, 0xe0, 0xa, 0x30, 0xc, 0x0, 0xc, 0x0, + 0x9a, 0x0, + + /* U+007E "~" */ + 0x4d, 0xb4, 0x34, 0x50, 0x4c, 0xc2, + + /* U+00A0 " " */ + + /* U+00A3 "£" */ + 0x7, 0xbc, 0x60, 0x2c, 0x0, 0xb0, 0x2c, 0x0, + 0x0, 0x8f, 0xb5, 0x0, 0xc, 0x20, 0x0, 0x1b, + 0x0, 0x0, 0xac, 0xbc, 0xc1, 0x0, 0x0, 0x0, + + /* U+00A4 "¤" */ + 0x0, 0x0, 0x0, 0x5b, 0xcb, 0xc0, 0x2b, 0x2, + 0xb0, 0x2b, 0x2, 0xb0, 0x5b, 0xcb, 0xc0, 0x0, + 0x0, 0x0, + + /* U+00A5 "¥" */ + 0xa4, 0x0, 0xc3, 0x1d, 0x6, 0x90, 0x6, 0x8d, + 0x10, 0x7b, 0xfd, 0xb2, 0x0, 0xa3, 0x0, 0x6a, + 0xdb, 0xa2, 0x0, 0xa3, 0x0, + + /* U+00A6 "¦" */ + 0x1b, 0x1b, 0x1b, 0x7, 0x0, 0x7, 0x1b, 0x1b, + 0x1b, + + /* U+00A7 "§" */ + 0x9, 0xbc, 0x30, 0xd, 0x3, 0x60, 0xc, 0xa1, + 0x0, 0x66, 0x5d, 0x50, 0x69, 0x1, 0xd0, 0x8, + 0xc5, 0xc0, 0x0, 0x2c, 0x50, 0x29, 0x2, 0xb0, + 0x9, 0xbc, 0x40, + + /* U+00A8 "¨" */ + 0xa3, 0xd0, + + /* U+00A9 "©" */ + 0x2, 0x89, 0x84, 0x0, 0x39, 0x58, 0x85, 0x80, + 0xa1, 0xa0, 0x32, 0x72, 0xa3, 0x70, 0x0, 0x45, + 0xa1, 0x90, 0x43, 0x82, 0x3a, 0x68, 0x86, 0x80, + 0x1, 0x89, 0x94, 0x0, + + /* U+00AA "ª" */ + 0x7a, 0xa7, 0xc0, 0x83, 0x69, 0xa7, + + /* U+00AB "«" */ + 0x0, 0x20, 0x20, 0x48, 0x66, 0x1c, 0x3c, 0x0, + 0xc2, 0xc0, 0x2, 0x94, 0x80, + + /* U+00AC "¬" */ + 0x5c, 0xcc, 0xe4, 0x0, 0x0, 0x84, 0x0, 0x0, + 0x63, + + /* U+00AD "­" */ + 0x9d, 0xd0, + + /* U+00AE "®" */ + 0x2, 0x89, 0x84, 0x0, 0x39, 0xa8, 0x75, 0x80, + 0xa0, 0xa0, 0xa1, 0x72, 0xa0, 0xca, 0x80, 0x45, + 0xa0, 0xa0, 0xa0, 0x82, 0x3a, 0x40, 0x27, 0x80, + 0x1, 0x89, 0x94, 0x0, + + /* U+00B0 "°" */ + 0x8, 0x80, 0x44, 0x44, 0x8, 0x80, + + /* U+00B1 "±" */ + 0x0, 0x32, 0x0, 0x0, 0x85, 0x0, 0x5c, 0xed, + 0xc3, 0x0, 0x85, 0x0, 0x0, 0x85, 0x0, 0x5c, + 0xcc, 0xc3, + + /* U+00B2 "²" */ + 0x7a, 0xc0, 0x3, 0x80, 0x8d, 0x91, + + /* U+00B3 "³" */ + 0x2d, 0xb0, 0x30, 0xb1, 0x7a, 0xa0, + + /* U+00B5 "µ" */ + 0x58, 0x0, 0xd5, 0x80, 0xd, 0x58, 0x0, 0xd5, + 0xb0, 0x2e, 0x5d, 0xab, 0xd5, 0x80, 0x0, 0x58, + 0x0, 0x0, + + /* U+00B6 "¶" */ + 0x4, 0xdf, 0xde, 0x40, 0xef, 0xc2, 0xa0, 0xe, + 0xfc, 0x2a, 0x0, 0x5d, 0xc2, 0xa0, 0x0, 0xc, + 0x2a, 0x0, 0x0, 0xc2, 0xa0, 0x0, 0xc, 0x2a, + 0x0, 0x0, 0xc2, 0xa0, 0x0, 0xc, 0x2a, 0x0, + + /* U+00B7 "·" */ + 0x1d, + + /* U+00BB "»" */ + 0x1, 0x11, 0x0, 0xb2, 0xb0, 0x4, 0xa5, 0x90, + 0x68, 0x77, 0x1b, 0x2a, 0x0, + + /* U+00BD "½" */ + 0x3, 0x20, 0x0, 0x50, 0x4, 0xb5, 0x0, 0x48, + 0x0, 0x6, 0x50, 0x1a, 0x0, 0x0, 0x65, 0xa, + 0x10, 0x0, 0x0, 0x7, 0x54, 0x98, 0x0, 0x3, + 0x90, 0x30, 0xb1, 0x0, 0xa0, 0x1, 0x93, 0x0, + 0x72, 0x0, 0x9b, 0xb1, + + /* U+0384 "΄" */ + 0x0, 0x86, 0x20, + + /* U+0386 "Ά" */ + 0x5a, 0x7e, 0x0, 0x2, 0xc, 0x86, 0x0, 0x3, + 0xa2, 0xc0, 0x0, 0xa4, 0xc, 0x30, 0xe, 0xbb, + 0xda, 0x6, 0x80, 0x0, 0xe1, 0xc2, 0x0, 0x9, + 0x70, + + /* U+0388 "Έ" */ + 0x1d, 0x2f, 0xcc, 0xcc, 0x11, 0x10, 0xe0, 0x0, + 0x0, 0x0, 0xe, 0x0, 0x0, 0x0, 0x0, 0xfc, + 0xcc, 0xa0, 0x0, 0xe, 0x0, 0x0, 0x0, 0x0, + 0xe0, 0x0, 0x0, 0x0, 0xf, 0xcc, 0xcc, 0x30, + + /* U+0389 "Ή" */ + 0x1d, 0x5b, 0x0, 0x9, 0x61, 0x13, 0xb0, 0x0, + 0x96, 0x0, 0x3b, 0x0, 0x9, 0x60, 0x3, 0xec, + 0xcc, 0xe6, 0x0, 0x3b, 0x0, 0x9, 0x60, 0x3, + 0xb0, 0x0, 0x96, 0x0, 0x3b, 0x0, 0x9, 0x60, + + /* U+038A "Ί" */ + 0x1d, 0x5b, 0x11, 0x3b, 0x0, 0x3b, 0x0, 0x3b, + 0x0, 0x3b, 0x0, 0x3b, 0x0, 0x3b, + + /* U+038C "Ό" */ + 0x1d, 0x3b, 0xcc, 0x80, 0x2, 0x3d, 0x30, 0x7, + 0xa0, 0x6, 0x90, 0x0, 0xe, 0x10, 0x87, 0x0, + 0x0, 0xb3, 0x6, 0x90, 0x0, 0xd, 0x10, 0x1e, + 0x30, 0x7, 0xa0, 0x0, 0x2b, 0xcc, 0x90, 0x0, + + /* U+038E "Ύ" */ + 0x1d, 0x1c, 0x50, 0x1, 0xd1, 0x11, 0x2, 0xe1, + 0xb, 0x50, 0x0, 0x0, 0x6a, 0x5a, 0x0, 0x0, + 0x0, 0xb, 0xd0, 0x0, 0x0, 0x0, 0x6, 0x90, + 0x0, 0x0, 0x0, 0x6, 0x90, 0x0, 0x0, 0x0, + 0x6, 0x90, 0x0, + + /* U+038F "Ώ" */ + 0x1d, 0x3b, 0xcd, 0x80, 0x2, 0x3d, 0x40, 0xa, + 0x70, 0x4, 0xb0, 0x0, 0x2e, 0x0, 0x69, 0x0, + 0x0, 0xf0, 0x2, 0xc0, 0x0, 0x2b, 0x0, 0x9, + 0x50, 0xa, 0x30, 0x6, 0xcf, 0x4a, 0xec, 0x0, + + /* U+0390 "ΐ" */ + 0x95, 0x7b, 0x0, 0x0, 0x5, 0x80, 0x5, 0x80, + 0x5, 0x80, 0x5, 0x80, 0x5, 0x80, + + /* U+0391 "Α" */ + 0x0, 0x7e, 0x0, 0x0, 0xc, 0x86, 0x0, 0x3, + 0xa2, 0xc0, 0x0, 0xa4, 0xc, 0x30, 0xe, 0xbb, + 0xda, 0x6, 0x80, 0x0, 0xe1, 0xc2, 0x0, 0x9, + 0x70, + + /* U+0392 "Β" */ + 0x4e, 0xcc, 0xc3, 0x4, 0xb0, 0x4, 0xb0, 0x4b, + 0x0, 0x59, 0x4, 0xec, 0xdf, 0x40, 0x4b, 0x0, + 0x2e, 0x4, 0xb0, 0x1, 0xe0, 0x4e, 0xcc, 0xd6, + 0x0, + + /* U+0393 "Γ" */ + 0x3f, 0xcc, 0xc3, 0x3c, 0x0, 0x0, 0x3c, 0x0, + 0x0, 0x3c, 0x0, 0x0, 0x3c, 0x0, 0x0, 0x3c, + 0x0, 0x0, 0x3c, 0x0, 0x0, + + /* U+0394 "Δ" */ + 0x0, 0x7, 0xe0, 0x0, 0x0, 0xd, 0x86, 0x0, + 0x0, 0x4a, 0x2c, 0x0, 0x0, 0xa4, 0xc, 0x30, + 0x1, 0xe0, 0x6, 0xa0, 0x6, 0x80, 0x0, 0xe1, + 0xd, 0xdc, 0xcc, 0xf7, + + /* U+0395 "Ε" */ + 0x3f, 0xcc, 0xcc, 0x3, 0xb0, 0x0, 0x0, 0x3b, + 0x0, 0x0, 0x3, 0xfc, 0xcc, 0x80, 0x3b, 0x0, + 0x0, 0x3, 0xb0, 0x0, 0x0, 0x3f, 0xcc, 0xcc, + 0x10, + + /* U+0396 "Ζ" */ + 0x5c, 0xcc, 0xeb, 0x0, 0x2, 0xd2, 0x0, 0xd, + 0x50, 0x0, 0xa8, 0x0, 0x7, 0xb0, 0x0, 0x4d, + 0x0, 0x0, 0xcd, 0xcc, 0xca, + + /* U+0397 "Η" */ + 0x3c, 0x0, 0x8, 0x63, 0xc0, 0x0, 0x86, 0x3c, + 0x0, 0x8, 0x63, 0xfc, 0xcc, 0xe6, 0x3c, 0x0, + 0x8, 0x63, 0xc0, 0x0, 0x86, 0x3c, 0x0, 0x8, + 0x60, + + /* U+0398 "Θ" */ + 0x2, 0xac, 0xc9, 0x0, 0xd, 0x30, 0x6, 0xb0, + 0x5a, 0x0, 0x0, 0xd2, 0x77, 0x6c, 0xc3, 0xb4, + 0x69, 0x0, 0x0, 0xd2, 0xd, 0x30, 0x6, 0xb0, + 0x2, 0xbc, 0xc9, 0x0, + + /* U+0399 "Ι" */ + 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, + + /* U+039A "Κ" */ + 0x4b, 0x0, 0x4d, 0x24, 0xb0, 0x5d, 0x10, 0x4b, + 0x5c, 0x10, 0x4, 0xec, 0xd1, 0x0, 0x4d, 0x6, + 0xc0, 0x4, 0xb0, 0xa, 0x80, 0x4b, 0x0, 0x1e, + 0x40, + + /* U+039B "Λ" */ + 0x0, 0x5f, 0x10, 0x0, 0xb, 0x86, 0x0, 0x2, + 0xb1, 0xc0, 0x0, 0x85, 0xb, 0x30, 0xd, 0x0, + 0x59, 0x5, 0x90, 0x0, 0xe0, 0xc3, 0x0, 0x9, + 0x60, + + /* U+039C "Μ" */ + 0x4f, 0x50, 0x0, 0xd9, 0x4d, 0xa0, 0x3, 0xd9, + 0x4a, 0xc0, 0x9, 0x89, 0x4a, 0x75, 0xb, 0x59, + 0x4a, 0x2b, 0x47, 0x59, 0x4a, 0xc, 0xb2, 0x59, + 0x4a, 0x7, 0xc0, 0x59, + + /* U+039D "Ν" */ + 0x3f, 0x20, 0x7, 0x73, 0xec, 0x0, 0x77, 0x3b, + 0x97, 0x7, 0x73, 0xb0, 0xd2, 0x77, 0x3b, 0x4, + 0xc8, 0x73, 0xb0, 0x9, 0xe7, 0x3b, 0x0, 0xd, + 0x70, + + /* U+039E "Ξ" */ + 0x4c, 0xcc, 0xca, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xcc, 0xc4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5c, 0xcc, 0xcc, + + /* U+039F "Ο" */ + 0x2, 0xac, 0xc9, 0x0, 0xd, 0x30, 0x6, 0xb0, + 0x5a, 0x0, 0x0, 0xd2, 0x77, 0x0, 0x0, 0xb4, + 0x69, 0x0, 0x0, 0xd2, 0xd, 0x30, 0x6, 0xb0, + 0x2, 0xbc, 0xc9, 0x0, + + /* U+03A0 "Π" */ + 0x3f, 0xcc, 0xce, 0x63, 0xc0, 0x0, 0x86, 0x3c, + 0x0, 0x8, 0x63, 0xc0, 0x0, 0x86, 0x3c, 0x0, + 0x8, 0x63, 0xc0, 0x0, 0x86, 0x3c, 0x0, 0x8, + 0x60, + + /* U+03A1 "Ρ" */ + 0x3f, 0xcc, 0xd8, 0x3, 0xb0, 0x0, 0xe2, 0x3b, + 0x0, 0x1e, 0x13, 0xfc, 0xcc, 0x50, 0x3b, 0x0, + 0x0, 0x3, 0xb0, 0x0, 0x0, 0x3b, 0x0, 0x0, + 0x0, + + /* U+03A3 "Σ" */ + 0x4f, 0xcc, 0xc7, 0xb, 0x60, 0x0, 0x0, 0xb5, + 0x0, 0x0, 0x2e, 0x0, 0x1, 0xd3, 0x0, 0xc, + 0x50, 0x0, 0x4f, 0xcc, 0xca, + + /* U+03A4 "Τ" */ + 0x9c, 0xee, 0xcb, 0x0, 0x68, 0x0, 0x0, 0x68, + 0x0, 0x0, 0x68, 0x0, 0x0, 0x68, 0x0, 0x0, + 0x68, 0x0, 0x0, 0x68, 0x0, + + /* U+03A5 "Υ" */ + 0xa8, 0x0, 0xd, 0x30, 0xd3, 0x8, 0x80, 0x4, + 0xd3, 0xc0, 0x0, 0x9, 0xe2, 0x0, 0x0, 0x3b, + 0x0, 0x0, 0x3, 0xb0, 0x0, 0x0, 0x3b, 0x0, + 0x0, + + /* U+03A6 "Φ" */ + 0x0, 0x7, 0x70, 0x0, 0x5, 0xbd, 0xdb, 0x40, + 0x4c, 0x17, 0x71, 0xc4, 0x87, 0x7, 0x70, 0x78, + 0x4c, 0x17, 0x71, 0xc3, 0x4, 0xbd, 0xdb, 0x40, + 0x0, 0x7, 0x70, 0x0, 0x0, 0x1, 0x10, 0x0, + + /* U+03A7 "Χ" */ + 0x4d, 0x0, 0x1d, 0x10, 0x89, 0xc, 0x40, 0x0, + 0xcb, 0x70, 0x0, 0x6, 0xf1, 0x0, 0x1, 0xd7, + 0xc0, 0x0, 0xc4, 0xa, 0x80, 0x98, 0x0, 0xd, + 0x40, + + /* U+03A8 "Ψ" */ + 0x69, 0x4, 0xa0, 0x3b, 0x69, 0x4, 0xa0, 0x3b, + 0x4a, 0x4, 0xa0, 0x4a, 0x1d, 0x24, 0xa0, 0xb5, + 0x3, 0xbd, 0xeb, 0x60, 0x0, 0x4, 0xa0, 0x0, + 0x0, 0x4, 0xa0, 0x0, + + /* U+03A9 "Ω" */ + 0x2, 0xbc, 0xd7, 0x0, 0xe4, 0x0, 0xb6, 0x5a, + 0x0, 0x3, 0xd6, 0x80, 0x0, 0x1e, 0x3b, 0x0, + 0x3, 0xa0, 0x94, 0x0, 0xb2, 0x6d, 0xf3, 0xbe, + 0xc0, + + /* U+03AA "Ϊ" */ + 0xd2, 0xb1, 0xd0, 0x1d, 0x1, 0xd0, 0x1d, 0x1, + 0xd0, 0x1d, 0x1, 0xd0, + + /* U+03AB "Ϋ" */ + 0x0, 0xc3, 0xa0, 0xa, 0x80, 0x0, 0xd3, 0xd, + 0x30, 0x88, 0x0, 0x4d, 0x3c, 0x0, 0x0, 0x9e, + 0x20, 0x0, 0x3, 0xb0, 0x0, 0x0, 0x3b, 0x0, + 0x0, 0x3, 0xb0, 0x0, + + /* U+03AC "ά" */ + 0x0, 0x5a, 0x0, 0x0, 0x30, 0x0, 0xa, 0x99, + 0xb4, 0x78, 0x2, 0xf0, 0x95, 0x0, 0xd0, 0x78, + 0x2, 0xf0, 0xa, 0x99, 0xa3, + + /* U+03AD "έ" */ + 0x0, 0xc2, 0x0, 0x2, 0x0, 0x1b, 0xb9, 0x4, + 0x90, 0x0, 0x1e, 0xa0, 0x7, 0x70, 0x10, 0x2c, + 0xba, 0x0, + + /* U+03AE "ή" */ + 0x0, 0x69, 0x0, 0x3, 0x0, 0x5b, 0x9b, 0x65, + 0xb0, 0xd, 0x59, 0x0, 0xd5, 0x90, 0xe, 0x59, + 0x0, 0xe0, 0x0, 0xe, 0x0, 0x0, 0xe0, + + /* U+03AF "ί" */ + 0x1d, 0x11, 0x10, 0x58, 0x5, 0x80, 0x58, 0x5, + 0x80, 0x58, 0x0, + + /* U+03B0 "ΰ" */ + 0xb, 0x77, 0x70, 0x0, 0x0, 0x58, 0x1, 0xd5, + 0x80, 0x1d, 0x58, 0x1, 0xc4, 0xa0, 0x3b, 0xa, + 0xbc, 0x30, + + /* U+03B1 "α" */ + 0xa, 0x99, 0xb4, 0x78, 0x2, 0xf0, 0x95, 0x0, + 0xd0, 0x78, 0x2, 0xf0, 0xa, 0x99, 0xa3, + + /* U+03B2 "β" */ + 0x8, 0xbc, 0x30, 0x3a, 0x1, 0xc0, 0x49, 0x2, + 0xb0, 0x59, 0x7d, 0x40, 0x59, 0x1, 0xc2, 0x5c, + 0x0, 0xb3, 0x5c, 0x9a, 0x90, 0x59, 0x0, 0x0, + 0x59, 0x0, 0x0, + + /* U+03B3 "γ" */ + 0xb3, 0x3, 0xa4, 0x90, 0x94, 0xd, 0xd, 0x0, + 0x8a, 0x80, 0x2, 0xf2, 0x0, 0xe, 0x0, 0x0, + 0xe0, 0x0, + + /* U+03B4 "δ" */ + 0x1f, 0xba, 0x80, 0x3, 0xc3, 0x0, 0xa, 0xad, + 0x50, 0x78, 0x0, 0xd1, 0x94, 0x0, 0xb2, 0x68, + 0x0, 0xd0, 0xa, 0xbb, 0x40, + + /* U+03B5 "ε" */ + 0x1b, 0xb9, 0x4, 0x90, 0x0, 0x1e, 0xa0, 0x7, + 0x70, 0x10, 0x2c, 0xba, 0x0, + + /* U+03B6 "ζ" */ + 0x9, 0xbf, 0x30, 0xb, 0x30, 0xa, 0x40, 0x3, + 0xa0, 0x0, 0x85, 0x0, 0x8, 0x50, 0x0, 0x2d, + 0xd9, 0x0, 0x0, 0xb2, 0x0, 0x69, 0x0, + + /* U+03B7 "η" */ + 0x5b, 0x9b, 0x65, 0xb0, 0xd, 0x59, 0x0, 0xd5, + 0x90, 0xe, 0x59, 0x0, 0xe0, 0x0, 0xe, 0x0, + 0x0, 0xe0, + + /* U+03B8 "θ" */ + 0x8, 0xbb, 0x30, 0x3b, 0x2, 0xc0, 0x76, 0x0, + 0xd0, 0x8c, 0xaa, 0xe1, 0x76, 0x0, 0xd0, 0x3b, + 0x2, 0xc0, 0x8, 0xbb, 0x30, + + /* U+03B9 "ι" */ + 0x58, 0x58, 0x58, 0x58, 0x58, + + /* U+03BA "κ" */ + 0x58, 0x1c, 0x45, 0xac, 0x30, 0x5e, 0xc0, 0x5, + 0x86, 0xb0, 0x58, 0x8, 0x90, + + /* U+03BB "λ" */ + 0x8, 0x60, 0x0, 0x2c, 0x0, 0x2, 0xf2, 0x0, + 0x8d, 0x80, 0xd, 0x2d, 0x4, 0xa0, 0xa4, 0xa3, + 0x3, 0xa0, + + /* U+03BC "μ" */ + 0x58, 0x0, 0xd5, 0x80, 0xd, 0x58, 0x0, 0xd5, + 0xb0, 0x2e, 0x5d, 0xab, 0xd5, 0x80, 0x0, 0x58, + 0x0, 0x0, + + /* U+03BD "ν" */ + 0xa3, 0x3, 0xb4, 0x90, 0x94, 0xd, 0x1d, 0x0, + 0x7a, 0x80, 0x1, 0xf2, 0x0, + + /* U+03BE "ξ" */ + 0xa, 0xb8, 0x3, 0xa0, 0x0, 0x8, 0xe8, 0x1, + 0xc1, 0x0, 0x76, 0x0, 0x6, 0x90, 0x0, 0x9, + 0xda, 0x0, 0x0, 0xb3, 0x0, 0x6a, 0x0, + + /* U+03BF "ο" */ + 0xa, 0xbb, 0x40, 0x77, 0x0, 0xd0, 0x94, 0x0, + 0xb2, 0x78, 0x0, 0xd0, 0xa, 0xbc, 0x50, + + /* U+03C0 "π" */ + 0x8c, 0xda, 0xcd, 0x70, 0x67, 0x6, 0x80, 0x6, + 0x70, 0x68, 0x0, 0x67, 0x6, 0x80, 0x6, 0x70, + 0x68, 0x0, + + /* U+03C1 "ρ" */ + 0x7, 0xbb, 0x60, 0x2b, 0x0, 0xc2, 0x58, 0x0, + 0x94, 0x5b, 0x0, 0xc2, 0x5c, 0xbb, 0x60, 0x58, + 0x0, 0x0, 0x58, 0x0, 0x0, + + /* U+03C2 "ς" */ + 0x4, 0xbb, 0x73, 0xb0, 0x0, 0x85, 0x0, 0x6, + 0xa0, 0x0, 0x8, 0xc9, 0x0, 0x0, 0x96, 0x0, + 0xcc, 0x10, + + /* U+03C3 "σ" */ + 0xa, 0xcf, 0xeb, 0x78, 0x1, 0xd0, 0xa4, 0x0, + 0xb2, 0x77, 0x0, 0xd0, 0xa, 0xbb, 0x40, + + /* U+03C4 "τ" */ + 0x8c, 0xd7, 0x6, 0x70, 0x6, 0x70, 0x6, 0x70, + 0x6, 0x70, + + /* U+03C5 "υ" */ + 0x58, 0x1, 0xd5, 0x80, 0x1d, 0x58, 0x1, 0xc4, + 0xa0, 0x3b, 0xa, 0xbc, 0x30, + + /* U+03C6 "φ" */ + 0xa, 0x4d, 0xb5, 0x7, 0x62, 0xb0, 0xd0, 0x94, + 0x2b, 0xd, 0x15, 0xa2, 0xb3, 0xc0, 0x7, 0xce, + 0xa1, 0x0, 0x2, 0xb0, 0x0, 0x0, 0x2b, 0x0, + 0x0, + + /* U+03C7 "χ" */ + 0x87, 0x2, 0xc0, 0xd, 0xb, 0x30, 0x7, 0xaa, + 0x0, 0x1, 0xf4, 0x0, 0x8, 0x8b, 0x0, 0x1c, + 0xa, 0x40, 0xa5, 0x2, 0xd0, + + /* U+03C8 "ψ" */ + 0x67, 0xe, 0x5, 0x86, 0x70, 0xe0, 0x58, 0x67, + 0xe, 0x5, 0x84, 0xa0, 0xe0, 0x86, 0x8, 0xbf, + 0xba, 0x0, 0x0, 0xe0, 0x0, 0x0, 0xe, 0x0, + 0x0, + + /* U+03C9 "ω" */ + 0x1c, 0x0, 0x1, 0xc0, 0x67, 0x6, 0x40, 0xb3, + 0x85, 0x8, 0x50, 0x85, 0x67, 0xa, 0x70, 0xb3, + 0xb, 0xb7, 0x9b, 0x90, + + /* U+03CA "ϊ" */ + 0x39, 0x67, 0x0, 0x0, 0x5, 0x80, 0x5, 0x80, + 0x5, 0x80, 0x5, 0x80, 0x5, 0x80, + + /* U+03CB "ϋ" */ + 0x9, 0x4c, 0x10, 0x0, 0x0, 0x58, 0x1, 0xd5, + 0x80, 0x1d, 0x58, 0x1, 0xc4, 0xa0, 0x3b, 0xa, + 0xbc, 0x30, + + /* U+03CC "ό" */ + 0x0, 0x69, 0x0, 0x0, 0x30, 0x0, 0xa, 0xbb, + 0x40, 0x77, 0x0, 0xd0, 0x94, 0x0, 0xb2, 0x78, + 0x0, 0xd0, 0xa, 0xbc, 0x50, + + /* U+03CD "ύ" */ + 0x0, 0x78, 0x0, 0x3, 0x0, 0x58, 0x1, 0xd5, + 0x80, 0x1d, 0x58, 0x1, 0xc4, 0xa0, 0x3b, 0xa, + 0xbc, 0x30, + + /* U+03CE "ώ" */ + 0x0, 0x4, 0xb0, 0x0, 0x0, 0x2, 0x0, 0x0, + 0x1c, 0x0, 0x1, 0xc0, 0x67, 0x6, 0x40, 0xb3, + 0x85, 0x8, 0x50, 0x85, 0x67, 0xa, 0x70, 0xb3, + 0xb, 0xb7, 0x9b, 0x90, + + /* U+03F4 "ϴ" */ + 0x1a, 0x78, 0x60 +}; + + +/*--------------------- + * GLYPH DESCRIPTION + *--------------------*/ + +static const lv_font_fmt_txt_glyph_dsc_t glyph_dsc[] = { + {.bitmap_index = 0, .adv_w = 0, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0} /* id = 0 reserved */, + {.bitmap_index = 0, .adv_w = 44, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 0, .adv_w = 45, .box_w = 2, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7, .adv_w = 57, .box_w = 4, .box_h = 3, .ofs_x = 0, .ofs_y = 4}, + {.bitmap_index = 13, .adv_w = 89, .box_w = 6, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 34, .adv_w = 89, .box_w = 6, .box_h = 9, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 61, .adv_w = 142, .box_w = 9, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 93, .adv_w = 107, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 121, .adv_w = 30, .box_w = 2, .box_h = 3, .ofs_x = 0, .ofs_y = 4}, + {.bitmap_index = 124, .adv_w = 53, .box_w = 3, .box_h = 9, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 138, .adv_w = 53, .box_w = 3, .box_h = 9, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 152, .adv_w = 62, .box_w = 4, .box_h = 3, .ofs_x = 0, .ofs_y = 4}, + {.bitmap_index = 158, .adv_w = 93, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 1}, + {.bitmap_index = 173, .adv_w = 45, .box_w = 2, .box_h = 3, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 176, .adv_w = 53, .box_w = 4, .box_h = 1, .ofs_x = 0, .ofs_y = 2}, + {.bitmap_index = 178, .adv_w = 45, .box_w = 2, .box_h = 1, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 179, .adv_w = 44, .box_w = 3, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 190, .adv_w = 89, .box_w = 6, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 211, .adv_w = 89, .box_w = 3, .box_h = 7, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 222, .adv_w = 89, .box_w = 6, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 243, .adv_w = 89, .box_w = 6, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 264, .adv_w = 89, .box_w = 6, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 285, .adv_w = 89, .box_w = 6, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 306, .adv_w = 89, .box_w = 6, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 327, .adv_w = 89, .box_w = 6, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 348, .adv_w = 89, .box_w = 6, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 369, .adv_w = 89, .box_w = 6, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 390, .adv_w = 45, .box_w = 2, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 395, .adv_w = 45, .box_w = 2, .box_h = 7, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 402, .adv_w = 93, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 1}, + {.bitmap_index = 417, .adv_w = 93, .box_w = 6, .box_h = 3, .ofs_x = 0, .ofs_y = 2}, + {.bitmap_index = 426, .adv_w = 93, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 1}, + {.bitmap_index = 441, .adv_w = 89, .box_w = 6, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 462, .adv_w = 162, .box_w = 10, .box_h = 9, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 507, .adv_w = 107, .box_w = 7, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 532, .adv_w = 107, .box_w = 7, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 557, .adv_w = 116, .box_w = 7, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 582, .adv_w = 116, .box_w = 7, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 607, .adv_w = 107, .box_w = 7, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 632, .adv_w = 98, .box_w = 6, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 653, .adv_w = 124, .box_w = 8, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 681, .adv_w = 116, .box_w = 7, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 706, .adv_w = 45, .box_w = 2, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 713, .adv_w = 80, .box_w = 5, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 731, .adv_w = 107, .box_w = 7, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 756, .adv_w = 89, .box_w = 6, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 777, .adv_w = 133, .box_w = 8, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 805, .adv_w = 116, .box_w = 7, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 830, .adv_w = 124, .box_w = 8, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 858, .adv_w = 107, .box_w = 7, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 883, .adv_w = 124, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 915, .adv_w = 116, .box_w = 8, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 943, .adv_w = 107, .box_w = 7, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 968, .adv_w = 98, .box_w = 6, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 989, .adv_w = 116, .box_w = 7, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1014, .adv_w = 107, .box_w = 7, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1039, .adv_w = 151, .box_w = 10, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1074, .adv_w = 107, .box_w = 7, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1099, .adv_w = 107, .box_w = 7, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1124, .adv_w = 98, .box_w = 6, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1145, .adv_w = 45, .box_w = 3, .box_h = 9, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 1159, .adv_w = 44, .box_w = 3, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1170, .adv_w = 45, .box_w = 3, .box_h = 9, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 1184, .adv_w = 75, .box_w = 5, .box_h = 4, .ofs_x = 0, .ofs_y = 3}, + {.bitmap_index = 1194, .adv_w = 89, .box_w = 7, .box_h = 1, .ofs_x = -1, .ofs_y = -2}, + {.bitmap_index = 1198, .adv_w = 53, .box_w = 3, .box_h = 3, .ofs_x = 0, .ofs_y = 5}, + {.bitmap_index = 1203, .adv_w = 89, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1218, .adv_w = 89, .box_w = 6, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1239, .adv_w = 80, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1252, .adv_w = 89, .box_w = 5, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1270, .adv_w = 89, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1285, .adv_w = 45, .box_w = 4, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1299, .adv_w = 89, .box_w = 5, .box_h = 7, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 1317, .adv_w = 89, .box_w = 5, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1335, .adv_w = 36, .box_w = 2, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1342, .adv_w = 36, .box_w = 3, .box_h = 9, .ofs_x = -1, .ofs_y = -2}, + {.bitmap_index = 1356, .adv_w = 80, .box_w = 5, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1374, .adv_w = 36, .box_w = 2, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1381, .adv_w = 133, .box_w = 8, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1401, .adv_w = 89, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1414, .adv_w = 89, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1429, .adv_w = 89, .box_w = 6, .box_h = 7, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 1450, .adv_w = 89, .box_w = 5, .box_h = 7, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 1468, .adv_w = 53, .box_w = 4, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1478, .adv_w = 80, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1491, .adv_w = 45, .box_w = 3, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1502, .adv_w = 89, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1515, .adv_w = 80, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1528, .adv_w = 116, .box_w = 8, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1548, .adv_w = 80, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1561, .adv_w = 80, .box_w = 5, .box_h = 7, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 1579, .adv_w = 80, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1592, .adv_w = 53, .box_w = 4, .box_h = 9, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 1610, .adv_w = 42, .box_w = 2, .box_h = 9, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 1619, .adv_w = 53, .box_w = 4, .box_h = 9, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 1637, .adv_w = 93, .box_w = 6, .box_h = 2, .ofs_x = 0, .ofs_y = 3}, + {.bitmap_index = 1643, .adv_w = 44, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1643, .adv_w = 89, .box_w = 6, .box_h = 8, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 1667, .adv_w = 89, .box_w = 6, .box_h = 6, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1685, .adv_w = 89, .box_w = 6, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1706, .adv_w = 42, .box_w = 2, .box_h = 9, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 1715, .adv_w = 89, .box_w = 6, .box_h = 9, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 1742, .adv_w = 53, .box_w = 4, .box_h = 1, .ofs_x = 0, .ofs_y = 6}, + {.bitmap_index = 1744, .adv_w = 118, .box_w = 8, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1772, .adv_w = 60, .box_w = 4, .box_h = 3, .ofs_x = 0, .ofs_y = 4}, + {.bitmap_index = 1778, .adv_w = 89, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1791, .adv_w = 93, .box_w = 6, .box_h = 3, .ofs_x = 0, .ofs_y = 2}, + {.bitmap_index = 1800, .adv_w = 53, .box_w = 4, .box_h = 1, .ofs_x = 0, .ofs_y = 2}, + {.bitmap_index = 1802, .adv_w = 118, .box_w = 8, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1830, .adv_w = 64, .box_w = 4, .box_h = 3, .ofs_x = 0, .ofs_y = 4}, + {.bitmap_index = 1836, .adv_w = 93, .box_w = 6, .box_h = 6, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1854, .adv_w = 53, .box_w = 4, .box_h = 3, .ofs_x = 0, .ofs_y = 4}, + {.bitmap_index = 1860, .adv_w = 53, .box_w = 4, .box_h = 3, .ofs_x = 0, .ofs_y = 4}, + {.bitmap_index = 1866, .adv_w = 89, .box_w = 5, .box_h = 7, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 1884, .adv_w = 86, .box_w = 7, .box_h = 9, .ofs_x = -1, .ofs_y = -2}, + {.bitmap_index = 1916, .adv_w = 45, .box_w = 2, .box_h = 1, .ofs_x = 0, .ofs_y = 3}, + {.bitmap_index = 1917, .adv_w = 89, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1930, .adv_w = 133, .box_w = 9, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1966, .adv_w = 53, .box_w = 2, .box_h = 3, .ofs_x = 1, .ofs_y = 5}, + {.bitmap_index = 1969, .adv_w = 107, .box_w = 7, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1994, .adv_w = 125, .box_w = 9, .box_h = 7, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 2026, .adv_w = 134, .box_w = 9, .box_h = 7, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 2058, .adv_w = 61, .box_w = 4, .box_h = 7, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 2072, .adv_w = 124, .box_w = 9, .box_h = 7, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 2104, .adv_w = 137, .box_w = 10, .box_h = 7, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 2139, .adv_w = 120, .box_w = 9, .box_h = 7, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 2171, .adv_w = 36, .box_w = 4, .box_h = 7, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 2185, .adv_w = 107, .box_w = 7, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2210, .adv_w = 107, .box_w = 7, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2235, .adv_w = 88, .box_w = 6, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2256, .adv_w = 107, .box_w = 8, .box_h = 7, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 2284, .adv_w = 107, .box_w = 7, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2309, .adv_w = 98, .box_w = 6, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2330, .adv_w = 116, .box_w = 7, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2355, .adv_w = 124, .box_w = 8, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2383, .adv_w = 45, .box_w = 2, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2390, .adv_w = 107, .box_w = 7, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2415, .adv_w = 107, .box_w = 7, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2440, .adv_w = 133, .box_w = 8, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2468, .adv_w = 116, .box_w = 7, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2493, .adv_w = 104, .box_w = 6, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2514, .adv_w = 124, .box_w = 8, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2542, .adv_w = 116, .box_w = 7, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2567, .adv_w = 107, .box_w = 7, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2592, .adv_w = 99, .box_w = 6, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2613, .adv_w = 98, .box_w = 6, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2634, .adv_w = 107, .box_w = 7, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2659, .adv_w = 128, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 2691, .adv_w = 107, .box_w = 7, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2716, .adv_w = 134, .box_w = 8, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2744, .adv_w = 120, .box_w = 7, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2769, .adv_w = 45, .box_w = 3, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2781, .adv_w = 107, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2809, .adv_w = 93, .box_w = 6, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2830, .adv_w = 71, .box_w = 5, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2848, .adv_w = 89, .box_w = 5, .box_h = 9, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 2871, .adv_w = 36, .box_w = 3, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2882, .adv_w = 88, .box_w = 5, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2900, .adv_w = 93, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2915, .adv_w = 92, .box_w = 6, .box_h = 9, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 2942, .adv_w = 80, .box_w = 5, .box_h = 7, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 2960, .adv_w = 89, .box_w = 6, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2981, .adv_w = 71, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2994, .adv_w = 71, .box_w = 5, .box_h = 9, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 3017, .adv_w = 89, .box_w = 5, .box_h = 7, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 3035, .adv_w = 89, .box_w = 6, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3056, .adv_w = 36, .box_w = 2, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3061, .adv_w = 80, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3074, .adv_w = 80, .box_w = 5, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3092, .adv_w = 89, .box_w = 5, .box_h = 7, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 3110, .adv_w = 80, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3123, .adv_w = 72, .box_w = 5, .box_h = 9, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 3146, .adv_w = 89, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3161, .adv_w = 110, .box_w = 7, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3179, .adv_w = 91, .box_w = 6, .box_h = 7, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 3200, .adv_w = 77, .box_w = 5, .box_h = 7, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 3218, .adv_w = 99, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3233, .adv_w = 63, .box_w = 4, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3243, .adv_w = 88, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3256, .adv_w = 104, .box_w = 7, .box_h = 7, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 3281, .adv_w = 84, .box_w = 6, .box_h = 7, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 3302, .adv_w = 114, .box_w = 7, .box_h = 7, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 3327, .adv_w = 125, .box_w = 8, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3347, .adv_w = 36, .box_w = 4, .box_h = 7, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 3361, .adv_w = 88, .box_w = 5, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3379, .adv_w = 89, .box_w = 6, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3400, .adv_w = 88, .box_w = 5, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3418, .adv_w = 125, .box_w = 8, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3446, .adv_w = 53, .box_w = 5, .box_h = 1, .ofs_x = -1, .ofs_y = 6} +}; + +/*--------------------- + * CHARACTER MAPPING + *--------------------*/ + +static const uint8_t glyph_id_ofs_list_1[] = { + 0, 0, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 0, + 13, 14, 15, 16, 0, 17, 18, 19, + 0, 0, 0, 20, 0, 21 +}; + +static const uint8_t glyph_id_ofs_list_2[] = { + 0, 0, 1, 0, 2, 3, 4, 0, + 5 +}; + +/*Collect the unicode lists and glyph_id offsets*/ +static const lv_font_fmt_txt_cmap_t cmaps[] = +{ + { + .range_start = 32, .range_length = 95, .glyph_id_start = 1, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 160, .range_length = 30, .glyph_id_start = 96, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_1, .list_length = 30, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 900, .range_length = 9, .glyph_id_start = 118, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_2, .list_length = 9, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 910, .range_length = 20, .glyph_id_start = 124, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 931, .range_length = 44, .glyph_id_start = 144, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 1012, .range_length = 1, .glyph_id_start = 188, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + } +}; + + + +/*-------------------- + * ALL CUSTOM DATA + *--------------------*/ + +#if LVGL_VERSION_MAJOR == 8 +/*Store all the custom data of the font*/ +static lv_font_fmt_txt_glyph_cache_t cache; +#endif + +#if LVGL_VERSION_MAJOR >= 8 +static const lv_font_fmt_txt_dsc_t font_dsc = { +#else +static lv_font_fmt_txt_dsc_t font_dsc = { +#endif + .glyph_bitmap = glyph_bitmap, + .glyph_dsc = glyph_dsc, + .cmaps = cmaps, + .kern_dsc = NULL, + .kern_scale = 0, + .cmap_num = 6, + .bpp = 4, + .kern_classes = 0, + .bitmap_format = 0, +#if LVGL_VERSION_MAJOR == 8 + .cache = &cache +#endif + +}; + +extern const lv_font_t lv_font_montserrat_10; + + +/*----------------- + * PUBLIC FONT + *----------------*/ + +/*Initialize a public general font descriptor*/ +#if LVGL_VERSION_MAJOR >= 8 +const lv_font_t lv_font_arial_10 = { +#else +lv_font_t lv_font_arial_10 = { +#endif + .get_glyph_dsc = lv_font_get_glyph_dsc_fmt_txt, /*Function pointer to get glyph's data*/ + .get_glyph_bitmap = lv_font_get_bitmap_fmt_txt, /*Function pointer to get glyph's bitmap*/ + .line_height = 10, /*The maximum line height required by the font*/ + .base_line = 2, /*Baseline measured from the bottom of the line*/ +#if !(LVGL_VERSION_MAJOR == 6 && LVGL_VERSION_MINOR == 0) + .subpx = LV_FONT_SUBPX_NONE, +#endif +#if LV_VERSION_CHECK(7, 4, 0) || LVGL_VERSION_MAJOR >= 8 + .underline_position = -1, + .underline_thickness = 1, +#endif + //.static_bitmap = 0, + .dsc = &font_dsc, /*The custom font data. Will be accessed by `get_glyph_bitmap/dsc` */ +#if LV_VERSION_CHECK(8, 2, 0) || LVGL_VERSION_MAJOR >= 9 + .fallback = &lv_font_montserrat_10, +#endif + .user_data = NULL, +}; + + + +#endif /*#if LV_FONT_ARIAL_10*/ diff --git a/src/fonts/lv_font_arial_12.c b/src/fonts/lv_font_arial_12.c new file mode 100644 index 0000000000..c1418ac534 --- /dev/null +++ b/src/fonts/lv_font_arial_12.c @@ -0,0 +1,1358 @@ +/******************************************************************************* + * Size: 12 px + * Bpp: 4 + * Opts: --bpp 4 --size 12 --no-compress --stride 1 --align 1 --font Arial Greek Regular.ttf --range 32-127,160-255,880-1023 --format lvgl -o lv_font_arial_12.c + ******************************************************************************/ + +#ifdef __has_include + #if __has_include("lvgl.h") + #ifndef LV_LVGL_H_INCLUDE_SIMPLE + #define LV_LVGL_H_INCLUDE_SIMPLE + #endif + #endif +#endif + +#ifdef LV_LVGL_H_INCLUDE_SIMPLE + #include "lvgl.h" +#else + #include "lvgl/lvgl.h" +#endif + + + +#ifndef LV_FONT_ARIAL_12 +#define LV_FONT_ARIAL_12 1 +#endif + +#if LV_FONT_ARIAL_12 + +/*----------------- + * BITMAPS + *----------------*/ + +/*Store the image of the glyphs*/ +static LV_ATTRIBUTE_LARGE_CONST const uint8_t glyph_bitmap[] = { + /* U+0020 " " */ + + /* U+0021 "!" */ + 0xf5, 0xf5, 0xe4, 0xd3, 0xc2, 0xb0, 0x30, 0xf4, + + /* U+0022 "\"" */ + 0x7c, 0x8b, 0x6b, 0x7a, 0x38, 0x47, + + /* U+0023 "#" */ + 0x0, 0xb2, 0xd, 0x0, 0xd, 0x3, 0xa0, 0xbd, + 0xed, 0xee, 0x70, 0x67, 0xa, 0x30, 0x9, 0x40, + 0xd0, 0xb, 0xfd, 0xdf, 0xd7, 0xd, 0x4, 0x90, + 0x4, 0x90, 0x85, 0x0, + + /* U+0024 "$" */ + 0x1, 0x6c, 0x40, 0x0, 0xe8, 0xcc, 0x80, 0x4b, + 0xa, 0x27, 0x2, 0xe2, 0xa0, 0x0, 0x5, 0xde, + 0x81, 0x0, 0x0, 0xb9, 0xd0, 0x35, 0xa, 0xf, + 0x14, 0xd1, 0xa4, 0xe0, 0x7, 0xde, 0xc3, 0x0, + 0x0, 0xa0, 0x0, + + /* U+0025 "%" */ + 0xa, 0xba, 0x0, 0x1b, 0x0, 0x3b, 0x9, 0x50, + 0x93, 0x0, 0x2b, 0xa, 0x43, 0xa0, 0x0, 0x7, + 0xb8, 0xb, 0x10, 0x0, 0x0, 0x0, 0x67, 0x1a, + 0xb3, 0x0, 0x0, 0xc0, 0x95, 0x1d, 0x0, 0x8, + 0x40, 0xa4, 0xd, 0x0, 0x2b, 0x0, 0x3b, 0xb5, + + /* U+0026 "&" */ + 0x0, 0xad, 0xd3, 0x0, 0x5, 0xc0, 0x7a, 0x0, + 0x2, 0xe2, 0xb6, 0x0, 0x1, 0xbf, 0x70, 0x0, + 0x1d, 0x77, 0xd2, 0xa0, 0x6b, 0x0, 0x9f, 0xb0, + 0x4e, 0x20, 0x5f, 0xc1, 0x7, 0xde, 0xb2, 0xa7, + 0x0, 0x0, 0x0, 0x0, + + /* U+0027 "'" */ + 0x7c, 0x6b, 0x37, + + /* U+0028 "(" */ + 0x0, 0x84, 0x3, 0xa0, 0xb, 0x40, 0x1f, 0x0, + 0x3d, 0x0, 0x3d, 0x0, 0x1f, 0x0, 0xb, 0x40, + 0x3, 0xa0, 0x0, 0x84, + + /* U+0029 ")" */ + 0x48, 0x0, 0xb, 0x30, 0x4, 0xb0, 0x0, 0xf1, + 0x0, 0xd3, 0x0, 0xd3, 0x0, 0xf1, 0x4, 0xb0, + 0xb, 0x30, 0x49, 0x0, + + /* U+002A "*" */ + 0x1, 0xb0, 0x5, 0xbe, 0xb1, 0xa, 0xa6, 0x0, + 0x30, 0x30, + + /* U+002B "+" */ + 0x0, 0x5, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x0, + 0xf, 0x0, 0x4, 0xff, 0xff, 0xf5, 0x0, 0xf, + 0x0, 0x0, 0x0, 0xf0, 0x0, + + /* U+002C "," */ + 0x2, 0x0, 0xf4, 0x8, 0x20, 0x50, + + /* U+002D "-" */ + 0xaf, 0xfa, + + /* U+002E "." */ + 0x20, 0xf4, + + /* U+002F "/" */ + 0x0, 0xa2, 0x0, 0xc0, 0x4, 0x80, 0x9, 0x30, + 0xd, 0x0, 0x39, 0x0, 0x84, 0x0, 0xc0, 0x0, + + /* U+0030 "0" */ + 0x4, 0xcd, 0xb1, 0x0, 0xe2, 0x7, 0xa0, 0x5b, + 0x0, 0x1f, 0x6, 0xa0, 0x0, 0xf1, 0x7a, 0x0, + 0xf, 0x15, 0xb0, 0x1, 0xf0, 0xe, 0x20, 0x8a, + 0x0, 0x4c, 0xdb, 0x10, + + /* U+0031 "1" */ + 0x0, 0x98, 0x1a, 0xf8, 0x86, 0x98, 0x0, 0x98, + 0x0, 0x98, 0x0, 0x98, 0x0, 0x98, 0x0, 0x98, + + /* U+0032 "2" */ + 0x6, 0xdd, 0xc3, 0x3, 0xe1, 0x5, 0xd0, 0x24, + 0x0, 0x2f, 0x0, 0x0, 0xa, 0x90, 0x0, 0xa, + 0xa0, 0x0, 0x1d, 0x80, 0x0, 0x1d, 0x50, 0x0, + 0x8, 0xff, 0xff, 0xf0, + + /* U+0033 "3" */ + 0x6, 0xdd, 0xb1, 0x2, 0xe1, 0x8, 0x90, 0x0, + 0x0, 0xa9, 0x0, 0x4, 0xde, 0x20, 0x0, 0x0, + 0x6e, 0x2, 0x40, 0x0, 0xf1, 0x3e, 0x10, 0x6d, + 0x0, 0x6d, 0xdb, 0x20, + + /* U+0034 "4" */ + 0x0, 0x4, 0xf0, 0x0, 0x2, 0xdf, 0x0, 0x0, + 0xc4, 0xf0, 0x0, 0xa6, 0x1f, 0x0, 0x6a, 0x1, + 0xf0, 0xc, 0xee, 0xef, 0xe1, 0x0, 0x1, 0xf0, + 0x0, 0x0, 0x1f, 0x0, + + /* U+0035 "5" */ + 0x9, 0xff, 0xfc, 0x0, 0xc3, 0x0, 0x0, 0xf, + 0xbe, 0xb2, 0x2, 0xb2, 0x8, 0xd0, 0x0, 0x0, + 0xf, 0x23, 0x50, 0x0, 0xf1, 0x3e, 0x10, 0x7c, + 0x0, 0x6d, 0xdb, 0x10, + + /* U+0036 "6" */ + 0x3, 0xcd, 0xc3, 0x0, 0xe4, 0x5, 0xd0, 0x5c, + 0x0, 0x2, 0x7, 0xaa, 0xec, 0x30, 0x7f, 0x30, + 0x5e, 0x6, 0xc0, 0x0, 0xf1, 0x1e, 0x20, 0x4e, + 0x0, 0x3c, 0xdc, 0x30, + + /* U+0037 "7" */ + 0x6f, 0xff, 0xff, 0x20, 0x0, 0x9, 0x80, 0x0, + 0x5, 0xd0, 0x0, 0x0, 0xd4, 0x0, 0x0, 0x5c, + 0x0, 0x0, 0xb, 0x60, 0x0, 0x0, 0xf2, 0x0, + 0x0, 0x2f, 0x0, 0x0, + + /* U+0038 "8" */ + 0x5, 0xdd, 0xb2, 0x0, 0xf2, 0x7, 0xb0, 0xf, + 0x30, 0x8a, 0x0, 0x6f, 0xee, 0x20, 0x2e, 0x20, + 0x6d, 0x7, 0xa0, 0x0, 0xf2, 0x3e, 0x10, 0x4e, + 0x0, 0x6d, 0xdc, 0x30, + + /* U+0039 "9" */ + 0x6, 0xdd, 0xa1, 0x3, 0xe1, 0x6, 0xb0, 0x7a, + 0x0, 0xf, 0x3, 0xe2, 0x7, 0xf2, 0x6, 0xdd, + 0x7e, 0x20, 0x20, 0x1, 0xf0, 0x2e, 0x10, 0x9a, + 0x0, 0x6d, 0xd9, 0x0, + + /* U+003A ":" */ + 0xf4, 0x20, 0x0, 0x0, 0x20, 0xf4, + + /* U+003B ";" */ + 0xf, 0x40, 0x20, 0x0, 0x0, 0x0, 0x2, 0x0, + 0xf4, 0x8, 0x20, 0x50, + + /* U+003C "<" */ + 0x0, 0x0, 0x6, 0x30, 0x3, 0x9e, 0x91, 0x2c, + 0xb5, 0x0, 0x2, 0xcb, 0x50, 0x0, 0x0, 0x39, + 0xe9, 0x10, 0x0, 0x0, 0x63, + + /* U+003D "=" */ + 0x4e, 0xee, 0xee, 0x50, 0x0, 0x0, 0x0, 0x4e, + 0xee, 0xee, 0x40, + + /* U+003E ">" */ + 0x36, 0x0, 0x0, 0x1, 0x9e, 0x93, 0x0, 0x0, + 0x5, 0xbc, 0x30, 0x0, 0x5b, 0xc3, 0x19, 0xe9, + 0x30, 0x3, 0x60, 0x0, 0x0, + + /* U+003F "?" */ + 0x6, 0xdd, 0xc3, 0x3, 0xe1, 0x5, 0xe0, 0x24, + 0x0, 0x1f, 0x0, 0x0, 0x1c, 0x70, 0x0, 0xd, + 0x60, 0x0, 0x2, 0xd0, 0x0, 0x0, 0x2, 0x0, + 0x0, 0x4, 0xe0, 0x0, + + /* U+0040 "@" */ + 0x0, 0x5, 0xbc, 0xcd, 0xa3, 0x0, 0x0, 0xaa, + 0x20, 0x0, 0x4c, 0x50, 0x7, 0x80, 0x7e, 0xd6, + 0xd0, 0xd1, 0xd, 0x6, 0xc0, 0xd, 0xa0, 0x76, + 0x3a, 0xe, 0x30, 0xa, 0x60, 0x67, 0x49, 0xf, + 0x0, 0xd, 0x30, 0xb3, 0x2c, 0xe, 0x50, 0x9f, + 0x8, 0xa0, 0xc, 0x44, 0xdd, 0x6d, 0xe8, 0x1, + 0x1, 0xd7, 0x10, 0x0, 0x5, 0xc3, 0x0, 0x7, + 0xcd, 0xdc, 0xc7, 0x10, + + /* U+0041 "A" */ + 0x0, 0xe, 0xb0, 0x0, 0x0, 0x5, 0xbe, 0x20, + 0x0, 0x0, 0xb6, 0x99, 0x0, 0x0, 0x2f, 0x13, + 0xf1, 0x0, 0x8, 0xa0, 0xd, 0x70, 0x0, 0xee, + 0xee, 0xee, 0x0, 0x6d, 0x0, 0x0, 0xe5, 0xc, + 0x60, 0x0, 0x8, 0xc0, + + /* U+0042 "B" */ + 0x1f, 0xff, 0xfc, 0x30, 0x1f, 0x0, 0x6, 0xd0, + 0x1f, 0x0, 0x6, 0xc0, 0x1f, 0xff, 0xff, 0x40, + 0x1f, 0x0, 0x5, 0xf2, 0x1f, 0x0, 0x0, 0xd5, + 0x1f, 0x0, 0x4, 0xf2, 0x1f, 0xff, 0xfd, 0x50, + + /* U+0043 "C" */ + 0x0, 0x7d, 0xfe, 0x80, 0x0, 0xac, 0x20, 0x1b, + 0xa0, 0x2f, 0x10, 0x0, 0x16, 0x5, 0xd0, 0x0, + 0x0, 0x0, 0x4d, 0x0, 0x0, 0x0, 0x1, 0xf1, + 0x0, 0x1, 0xc0, 0x9, 0xc2, 0x1, 0xba, 0x0, + 0x8, 0xdf, 0xe8, 0x0, + + /* U+0044 "D" */ + 0x1f, 0xff, 0xfd, 0x60, 0x1, 0xf1, 0x0, 0x3e, + 0x50, 0x1f, 0x10, 0x0, 0x6d, 0x1, 0xf1, 0x0, + 0x2, 0xf0, 0x1f, 0x10, 0x0, 0x2f, 0x1, 0xf1, + 0x0, 0x6, 0xc0, 0x1f, 0x10, 0x3, 0xe5, 0x1, + 0xff, 0xff, 0xd5, 0x0, + + /* U+0045 "E" */ + 0xf, 0xff, 0xff, 0xf2, 0xf, 0x10, 0x0, 0x0, + 0xf, 0x10, 0x0, 0x0, 0xf, 0xff, 0xff, 0xc0, + 0xf, 0x10, 0x0, 0x0, 0xf, 0x10, 0x0, 0x0, + 0xf, 0x10, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf5, + + /* U+0046 "F" */ + 0xf, 0xff, 0xff, 0xb0, 0xf1, 0x0, 0x0, 0xf, + 0x10, 0x0, 0x0, 0xff, 0xff, 0xf1, 0xf, 0x10, + 0x0, 0x0, 0xf1, 0x0, 0x0, 0xf, 0x10, 0x0, + 0x0, 0xf1, 0x0, 0x0, + + /* U+0047 "G" */ + 0x0, 0x6d, 0xfe, 0xb3, 0x0, 0x8d, 0x30, 0x6, + 0xe1, 0x1f, 0x20, 0x0, 0x6, 0x25, 0xd0, 0x0, + 0x0, 0x0, 0x5e, 0x0, 0x1f, 0xff, 0x81, 0xf2, + 0x0, 0x0, 0x89, 0x8, 0xd4, 0x0, 0x4c, 0x80, + 0x6, 0xcf, 0xfc, 0x60, + + /* U+0048 "H" */ + 0xf, 0x10, 0x0, 0x7b, 0xf, 0x10, 0x0, 0x7b, + 0xf, 0x10, 0x0, 0x7b, 0xf, 0xff, 0xff, 0xfb, + 0xf, 0x10, 0x0, 0x7b, 0xf, 0x10, 0x0, 0x7b, + 0xf, 0x10, 0x0, 0x7b, 0xf, 0x10, 0x0, 0x7b, + + /* U+0049 "I" */ + 0xe3, 0xe3, 0xe3, 0xe3, 0xe3, 0xe3, 0xe3, 0xe3, + + /* U+004A "J" */ + 0x0, 0x1, 0xf1, 0x0, 0x1, 0xf1, 0x0, 0x1, + 0xf1, 0x0, 0x1, 0xf1, 0x0, 0x1, 0xf1, 0x43, + 0x1, 0xf0, 0x8a, 0x5, 0xe0, 0x1b, 0xfd, 0x40, + + /* U+004B "K" */ + 0x1f, 0x0, 0x4, 0xe4, 0x1f, 0x0, 0x5e, 0x30, + 0x1f, 0x6, 0xd2, 0x0, 0x1f, 0x7f, 0x70, 0x0, + 0x1f, 0xc4, 0xf3, 0x0, 0x1f, 0x0, 0x6e, 0x10, + 0x1f, 0x0, 0xa, 0xc0, 0x1f, 0x0, 0x0, 0xd9, + + /* U+004C "L" */ + 0x1f, 0x0, 0x0, 0x1, 0xf0, 0x0, 0x0, 0x1f, + 0x0, 0x0, 0x1, 0xf0, 0x0, 0x0, 0x1f, 0x0, + 0x0, 0x1, 0xf0, 0x0, 0x0, 0x1f, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xf4, + + /* U+004D "M" */ + 0x1f, 0xc0, 0x0, 0x9, 0xf1, 0x1f, 0xe2, 0x0, + 0xd, 0xf1, 0x1f, 0x88, 0x0, 0x58, 0xf1, 0x1f, + 0x2d, 0x0, 0xb2, 0xf1, 0x1f, 0xc, 0x31, 0xc0, + 0xf1, 0x1f, 0x6, 0x97, 0x70, 0xf1, 0x1f, 0x1, + 0xec, 0x10, 0xf1, 0x1f, 0x0, 0xbb, 0x0, 0xf1, + + /* U+004E "N" */ + 0xf, 0x70, 0x0, 0x6b, 0xf, 0xf3, 0x0, 0x6b, + 0xf, 0x7d, 0x0, 0x6b, 0xf, 0xa, 0xa0, 0x6b, + 0xf, 0x1, 0xe5, 0x6b, 0xf, 0x0, 0x4e, 0x7b, + 0xf, 0x0, 0x8, 0xfb, 0xf, 0x0, 0x0, 0xcb, + + /* U+004F "O" */ + 0x0, 0x7d, 0xfe, 0x91, 0x0, 0x9c, 0x20, 0x19, + 0xd1, 0x2f, 0x10, 0x0, 0xb, 0x86, 0xd0, 0x0, + 0x0, 0x7b, 0x6c, 0x0, 0x0, 0x7, 0xb2, 0xf1, + 0x0, 0x0, 0xb8, 0x9, 0xc2, 0x1, 0x8e, 0x10, + 0x7, 0xde, 0xe9, 0x10, + + /* U+0050 "P" */ + 0x1f, 0xff, 0xfe, 0x70, 0x1f, 0x10, 0x2, 0xe4, + 0x1f, 0x10, 0x0, 0xb7, 0x1f, 0x10, 0x3, 0xf3, + 0x1f, 0xff, 0xfd, 0x60, 0x1f, 0x10, 0x0, 0x0, + 0x1f, 0x10, 0x0, 0x0, 0x1f, 0x10, 0x0, 0x0, + + /* U+0051 "Q" */ + 0x0, 0x7d, 0xfe, 0x91, 0x0, 0x9c, 0x20, 0x18, + 0xd1, 0x2f, 0x10, 0x0, 0xb, 0x76, 0xd0, 0x0, + 0x0, 0x7b, 0x6c, 0x0, 0x0, 0x7, 0xb2, 0xf1, + 0x0, 0x20, 0xb8, 0x9, 0xc2, 0x1c, 0xcd, 0x10, + 0x7, 0xdf, 0xea, 0xd6, 0x0, 0x0, 0x0, 0x0, + 0x40, + + /* U+0052 "R" */ + 0xf, 0xee, 0xee, 0xc2, 0x0, 0xf1, 0x0, 0x9, + 0xb0, 0xf, 0x10, 0x1, 0xaa, 0x0, 0xff, 0xff, + 0xe9, 0x10, 0xf, 0x10, 0x4e, 0x30, 0x0, 0xf1, + 0x0, 0x6e, 0x10, 0xf, 0x10, 0x0, 0xc9, 0x0, + 0xf1, 0x0, 0x3, 0xf3, + + /* U+0053 "S" */ + 0x3, 0xce, 0xeb, 0x20, 0xe, 0x50, 0x7, 0xd0, + 0xf, 0x20, 0x0, 0x60, 0x5, 0xec, 0x84, 0x0, + 0x0, 0x3, 0x7c, 0xc0, 0x48, 0x0, 0x0, 0xd5, + 0x2f, 0x60, 0x4, 0xe2, 0x3, 0xbe, 0xfc, 0x40, + + /* U+0054 "T" */ + 0xbf, 0xff, 0xff, 0xf0, 0x0, 0xe, 0x30, 0x0, + 0x0, 0xe, 0x30, 0x0, 0x0, 0xe, 0x30, 0x0, + 0x0, 0xe, 0x30, 0x0, 0x0, 0xe, 0x30, 0x0, + 0x0, 0xe, 0x30, 0x0, 0x0, 0xe, 0x30, 0x0, + + /* U+0055 "U" */ + 0xf, 0x10, 0x0, 0x6b, 0xf, 0x10, 0x0, 0x6b, + 0xf, 0x10, 0x0, 0x6b, 0xf, 0x10, 0x0, 0x6b, + 0xf, 0x10, 0x0, 0x6b, 0xe, 0x20, 0x0, 0x8a, + 0xa, 0xa1, 0x3, 0xe5, 0x1, 0xae, 0xfd, 0x60, + + /* U+0056 "V" */ + 0xb7, 0x0, 0x0, 0x7b, 0x5d, 0x0, 0x0, 0xd4, + 0xe, 0x40, 0x3, 0xd0, 0x7, 0xa0, 0xa, 0x70, + 0x1, 0xe0, 0x1e, 0x10, 0x0, 0xa6, 0x79, 0x0, + 0x0, 0x3c, 0xc2, 0x0, 0x0, 0xc, 0xc0, 0x0, + + /* U+0057 "W" */ + 0xb6, 0x0, 0x2f, 0x80, 0x1, 0xf0, 0x7a, 0x0, + 0x7b, 0xc0, 0x5, 0xb0, 0x2e, 0x0, 0xc3, 0xe1, + 0xa, 0x60, 0xe, 0x21, 0xe0, 0x96, 0xe, 0x20, + 0x9, 0x66, 0x90, 0x5b, 0x2d, 0x0, 0x4, 0xaa, + 0x40, 0xe, 0x68, 0x0, 0x0, 0xde, 0x0, 0xb, + 0xd4, 0x0, 0x0, 0xbb, 0x0, 0x6, 0xf0, 0x0, + + /* U+0058 "X" */ + 0x3f, 0x30, 0x1, 0xd4, 0x6, 0xd1, 0xb, 0x70, + 0x0, 0xaa, 0x8a, 0x0, 0x0, 0xd, 0xe0, 0x0, + 0x0, 0x3e, 0xf3, 0x0, 0x1, 0xe5, 0x6e, 0x10, + 0xb, 0x90, 0x9, 0xc0, 0x8c, 0x0, 0x0, 0xd8, + + /* U+0059 "Y" */ + 0x9c, 0x0, 0x0, 0xc8, 0xd, 0x70, 0x7, 0xc0, + 0x3, 0xf2, 0x3e, 0x10, 0x0, 0x7c, 0xd4, 0x0, + 0x0, 0xc, 0x90, 0x0, 0x0, 0xa, 0x70, 0x0, + 0x0, 0xa, 0x70, 0x0, 0x0, 0xa, 0x70, 0x0, + + /* U+005A "Z" */ + 0x4f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x1e, 0x60, + 0x0, 0x0, 0xd8, 0x0, 0x0, 0xb, 0xa0, 0x0, + 0x0, 0x9c, 0x0, 0x0, 0x7, 0xd1, 0x0, 0x0, + 0x5e, 0x20, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf0, + + /* U+005B "[" */ + 0x3f, 0xd1, 0x3d, 0x0, 0x3d, 0x0, 0x3d, 0x0, + 0x3d, 0x0, 0x3d, 0x0, 0x3d, 0x0, 0x3d, 0x0, + 0x3d, 0x0, 0x3f, 0xd1, + + /* U+005C "\\" */ + 0xc0, 0x0, 0x84, 0x0, 0x39, 0x0, 0xd, 0x0, + 0x9, 0x30, 0x4, 0x80, 0x0, 0xc0, 0x0, 0xa2, + + /* U+005D "]" */ + 0xae, 0x80, 0x88, 0x8, 0x80, 0x88, 0x8, 0x80, + 0x88, 0x8, 0x80, 0x88, 0x8, 0x8a, 0xe8, + + /* U+005E "^" */ + 0x0, 0x52, 0x0, 0x1, 0xeb, 0x0, 0x8, 0x7d, + 0x20, 0xe, 0x16, 0x90, 0x79, 0x0, 0xe1, + + /* U+005F "_" */ + 0xb, 0xbb, 0xbb, 0xb8, + + /* U+0060 "`" */ + 0x28, 0x0, 0x87, + + /* U+0061 "a" */ + 0x7, 0xdd, 0xd4, 0x2, 0xc0, 0x5, 0xc0, 0x1, + 0x58, 0xbd, 0x3, 0xe7, 0x45, 0xd0, 0x7a, 0x0, + 0x9d, 0x1, 0xcc, 0xc8, 0xf0, + + /* U+0062 "b" */ + 0x3d, 0x0, 0x0, 0x3, 0xd0, 0x0, 0x0, 0x3e, + 0xad, 0xc2, 0x3, 0xf4, 0x5, 0xd0, 0x3d, 0x0, + 0xf, 0x23, 0xd0, 0x0, 0xe1, 0x3f, 0x20, 0x4d, + 0x3, 0xda, 0xbb, 0x20, + + /* U+0063 "c" */ + 0x5, 0xdd, 0xb1, 0x3e, 0x10, 0x79, 0x79, 0x0, + 0x0, 0x79, 0x0, 0x2, 0x3e, 0x10, 0x7a, 0x5, + 0xdd, 0xb1, + + /* U+0064 "d" */ + 0x0, 0x0, 0x3d, 0x0, 0x0, 0x3d, 0x6, 0xdc, + 0x9d, 0x3e, 0x10, 0x9d, 0x79, 0x0, 0x3d, 0x79, + 0x0, 0x2d, 0x3e, 0x10, 0x8d, 0x6, 0xdc, 0x9d, + + /* U+0065 "e" */ + 0x5, 0xcc, 0xc3, 0x2, 0xd1, 0x3, 0xe0, 0x7e, + 0xdd, 0xde, 0x27, 0xa0, 0x0, 0x10, 0x3f, 0x20, + 0x4e, 0x0, 0x5d, 0xdc, 0x30, + + /* U+0066 "f" */ + 0x8, 0xe9, 0xf, 0x20, 0xbf, 0xc3, 0xf, 0x10, + 0xf, 0x10, 0xf, 0x10, 0xf, 0x10, 0xf, 0x10, + + /* U+0067 "g" */ + 0x6, 0xdc, 0x8e, 0x3e, 0x10, 0x9e, 0x88, 0x0, + 0x2e, 0x89, 0x0, 0x2e, 0x3d, 0x10, 0x8e, 0x6, + 0xdd, 0xad, 0x36, 0x0, 0x6a, 0xa, 0xdd, 0xb1, + + /* U+0068 "h" */ + 0x3d, 0x0, 0x0, 0x3d, 0x0, 0x0, 0x3e, 0x9d, + 0xd4, 0x3f, 0x40, 0x6c, 0x3e, 0x0, 0x2d, 0x3d, + 0x0, 0x2e, 0x3d, 0x0, 0x2e, 0x3d, 0x0, 0x2e, + + /* U+0069 "i" */ + 0x3d, 0x2, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, + + /* U+006A "j" */ + 0x3, 0xd0, 0x2, 0x3, 0xd0, 0x3d, 0x3, 0xd0, + 0x3d, 0x3, 0xd0, 0x3d, 0x3, 0xc5, 0xe6, + + /* U+006B "k" */ + 0x3d, 0x0, 0x0, 0x3d, 0x0, 0x0, 0x3d, 0x3, + 0xe3, 0x3d, 0x3d, 0x30, 0x3f, 0xf9, 0x0, 0x3f, + 0x3e, 0x30, 0x3d, 0x5, 0xd0, 0x3d, 0x0, 0xa9, + + /* U+006C "l" */ + 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, + + /* U+006D "m" */ + 0x3c, 0xab, 0xc5, 0xac, 0x90, 0x3f, 0x20, 0xac, + 0x0, 0xe2, 0x3e, 0x0, 0x88, 0x0, 0xd3, 0x3d, + 0x0, 0x88, 0x0, 0xd3, 0x3d, 0x0, 0x88, 0x0, + 0xd3, 0x3d, 0x0, 0x88, 0x0, 0xd3, + + /* U+006E "n" */ + 0x3d, 0x9b, 0xd4, 0x3f, 0x20, 0x5c, 0x3e, 0x0, + 0x3d, 0x3e, 0x0, 0x3e, 0x3e, 0x0, 0x3e, 0x3e, + 0x0, 0x3e, + + /* U+006F "o" */ + 0x5, 0xdd, 0xb2, 0x3, 0xe1, 0x5, 0xd0, 0x79, + 0x0, 0xe, 0x28, 0x90, 0x0, 0xe2, 0x3e, 0x10, + 0x5d, 0x0, 0x6d, 0xdc, 0x20, + + /* U+0070 "p" */ + 0x3d, 0xaa, 0xb3, 0x3, 0xf3, 0x3, 0xd0, 0x3d, + 0x0, 0xe, 0x23, 0xd0, 0x0, 0xe2, 0x3f, 0x30, + 0x5d, 0x3, 0xea, 0xdc, 0x20, 0x3e, 0x0, 0x0, + 0x3, 0xe0, 0x0, 0x0, + + /* U+0071 "q" */ + 0x6, 0xdc, 0x8d, 0x3e, 0x10, 0x9d, 0x79, 0x0, + 0x3d, 0x79, 0x0, 0x2d, 0x2e, 0x10, 0x8d, 0x5, + 0xdc, 0xad, 0x0, 0x0, 0x3d, 0x0, 0x0, 0x3d, + + /* U+0072 "r" */ + 0x3c, 0xcd, 0x3, 0xf2, 0x0, 0x3d, 0x0, 0x3, + 0xd0, 0x0, 0x3d, 0x0, 0x3, 0xd0, 0x0, + + /* U+0073 "s" */ + 0xa, 0xdd, 0x80, 0x6a, 0x0, 0xa1, 0x2e, 0xb7, + 0x20, 0x0, 0x48, 0xe4, 0x69, 0x0, 0xa7, 0xa, + 0xdd, 0xa0, + + /* U+0074 "t" */ + 0x0, 0x0, 0xc, 0x0, 0xf, 0x0, 0xaf, 0xc0, + 0xf, 0x0, 0xf, 0x0, 0xf, 0x0, 0xf, 0x0, + 0xb, 0xe2, + + /* U+0075 "u" */ + 0x3d, 0x0, 0x3d, 0x3d, 0x0, 0x3d, 0x3d, 0x0, + 0x3d, 0x3d, 0x0, 0x4d, 0x1f, 0x10, 0x9d, 0x8, + 0xec, 0x7d, + + /* U+0076 "v" */ + 0xa7, 0x0, 0x6a, 0x4d, 0x0, 0xc4, 0xd, 0x32, + 0xd0, 0x7, 0x98, 0x70, 0x1, 0xee, 0x10, 0x0, + 0xab, 0x0, + + /* U+0077 "w" */ + 0xc4, 0x5, 0xf0, 0x9, 0x67, 0x90, 0x9e, 0x40, + 0xe1, 0x2d, 0xd, 0x79, 0x3c, 0x0, 0xd5, 0xb2, + 0xd8, 0x70, 0x8, 0xd7, 0xd, 0xe2, 0x0, 0x3f, + 0x30, 0x9d, 0x0, + + /* U+0078 "x" */ + 0x5d, 0x0, 0xd5, 0xa, 0x99, 0x90, 0x0, 0xdd, + 0x0, 0x2, 0xee, 0x20, 0xc, 0x66, 0xc0, 0x8b, + 0x0, 0xb8, + + /* U+0079 "y" */ + 0x98, 0x0, 0x5a, 0x3e, 0x0, 0xc4, 0xc, 0x42, + 0xd0, 0x5, 0xb8, 0x70, 0x0, 0xed, 0x10, 0x0, + 0x8a, 0x0, 0x0, 0xd3, 0x0, 0x4f, 0x80, 0x0, + + /* U+007A "z" */ + 0x6c, 0xcc, 0xf8, 0x0, 0x6, 0xc0, 0x0, 0x5d, + 0x10, 0x4, 0xe2, 0x0, 0x3e, 0x30, 0x0, 0xbe, + 0xdd, 0xda, + + /* U+007B "{" */ + 0x1, 0xda, 0x6, 0x90, 0x7, 0x80, 0xb, 0x50, + 0xab, 0x0, 0xb, 0x40, 0x7, 0x80, 0x7, 0x80, + 0x6, 0x90, 0x1, 0xda, + + /* U+007C "|" */ + 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, + 0xe0, 0xe0, + + /* U+007D "}" */ + 0xad, 0x10, 0x9, 0x60, 0x8, 0x70, 0x5, 0xb0, + 0x0, 0xba, 0x4, 0xb0, 0x7, 0x70, 0x8, 0x70, + 0x9, 0x60, 0xad, 0x10, + + /* U+007E "~" */ + 0x2c, 0xd7, 0x12, 0x56, 0x43, 0xaf, 0xe3, 0x0, + 0x0, 0x0, 0x0, + + /* U+00A0 " " */ + + /* U+00A3 "£" */ + 0x5, 0xcd, 0xd4, 0x0, 0xf3, 0x2, 0xd0, 0xf, + 0x20, 0x0, 0x9, 0xfe, 0xd2, 0x0, 0x8, 0x90, + 0x0, 0x0, 0x97, 0x0, 0x0, 0x3e, 0x10, 0x0, + 0x9, 0xed, 0xde, 0xe2, 0x0, 0x0, 0x0, 0x0, + + /* U+00A4 "¤" */ + 0x1, 0x0, 0x1, 0x4, 0xdc, 0xeb, 0xd0, 0xe, + 0x40, 0x99, 0x1, 0xd0, 0x3, 0xc0, 0xe, 0x40, + 0x99, 0x4, 0xdc, 0xeb, 0xd0, 0x1, 0x0, 0x1, + 0x0, + + /* U+00A5 "¥" */ + 0xb7, 0x0, 0xd, 0x52, 0xe1, 0x6, 0xc0, 0x8, + 0x90, 0xe3, 0x0, 0xe, 0xaa, 0x0, 0x7d, 0xef, + 0xdd, 0x37, 0xcc, 0xfc, 0xc3, 0x0, 0x3e, 0x0, + 0x0, 0x3, 0xe0, 0x0, + + /* U+00A6 "¦" */ + 0xe0, 0xe0, 0xe0, 0xe0, 0x50, 0x50, 0xe0, 0xe0, + 0xe0, 0xe0, + + /* U+00A7 "§" */ + 0x4, 0xdd, 0xb1, 0x0, 0xd3, 0x9, 0x70, 0x9, + 0xb1, 0x0, 0x2, 0xb8, 0xe7, 0x0, 0x78, 0x1, + 0xbc, 0x1, 0xd5, 0x0, 0xe1, 0x0, 0x8b, 0x77, + 0x0, 0x0, 0x2c, 0x60, 0xe, 0x20, 0x7a, 0x0, + 0x5d, 0xdc, 0x20, + + /* U+00A8 "¨" */ + 0xa7, 0x7a, 0x11, 0x11, + + /* U+00A9 "©" */ + 0x0, 0x5a, 0xba, 0x40, 0x0, 0xa6, 0x0, 0x18, + 0x80, 0x75, 0x18, 0x98, 0x8, 0x5b, 0xa, 0x30, + 0x43, 0x1b, 0xb0, 0xc0, 0x0, 0x0, 0xbc, 0xa, + 0x30, 0x55, 0xb, 0x75, 0x19, 0xa8, 0x8, 0x50, + 0xa6, 0x0, 0x8, 0x90, 0x0, 0x6a, 0xba, 0x50, + 0x0, + + /* U+00AA "ª" */ + 0x2c, 0xac, 0x3a, 0x31, 0xf0, 0xc1, 0xc, 0xa, + 0x31, 0xf0, 0x2b, 0xbc, 0x30, + + /* U+00AB "«" */ + 0x0, 0x0, 0x0, 0x0, 0xb3, 0x77, 0x7, 0x93, + 0xd0, 0xf, 0x2b, 0x60, 0x6, 0xa2, 0xd0, 0x0, + 0xb3, 0x68, + + /* U+00AC "¬" */ + 0x4e, 0xee, 0xef, 0x50, 0x0, 0x0, 0xa5, 0x0, + 0x0, 0xa, 0x50, 0x0, 0x0, 0x42, + + /* U+00AD "­" */ + 0xaf, 0xfa, + + /* U+00AE "®" */ + 0x0, 0x5a, 0xba, 0x40, 0x0, 0xa6, 0x0, 0x18, + 0x80, 0x75, 0x6a, 0x98, 0x8, 0x5b, 0x8, 0x40, + 0xb1, 0x1b, 0xb0, 0x8b, 0xd7, 0x0, 0xbc, 0x8, + 0x44, 0x90, 0xb, 0x75, 0x73, 0x9, 0x38, 0x50, + 0xa6, 0x0, 0x8, 0x90, 0x0, 0x6a, 0xba, 0x50, + 0x0, + + /* U+00B0 "°" */ + 0x8, 0xa6, 0x2, 0x80, 0xa0, 0x8, 0xa6, 0x0, + + /* U+00B1 "±" */ + 0x0, 0xf, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x4e, + 0xef, 0xee, 0x40, 0x0, 0xf0, 0x0, 0x0, 0xf, + 0x0, 0x0, 0x0, 0x50, 0x0, 0x4e, 0xee, 0xee, + 0x50, + + /* U+00B2 "²" */ + 0x4c, 0xc5, 0x41, 0x3b, 0x1, 0xc5, 0x1d, 0x60, + 0xae, 0xb8, + + /* U+00B3 "³" */ + 0x4c, 0xc4, 0x31, 0x78, 0x3, 0xe3, 0x41, 0x3b, + 0x5c, 0xc5, + + /* U+00B5 "µ" */ + 0x2d, 0x0, 0x3d, 0x2d, 0x0, 0x3d, 0x2d, 0x0, + 0x3d, 0x2e, 0x0, 0x3d, 0x2f, 0x20, 0x7d, 0x2e, + 0xbc, 0xad, 0x2d, 0x0, 0x0, 0x2d, 0x0, 0x0, + + /* U+00B6 "¶" */ + 0x3, 0xcf, 0xff, 0xf7, 0xd, 0xff, 0x56, 0x90, + 0xf, 0xff, 0x56, 0x90, 0x9, 0xff, 0x56, 0x90, + 0x0, 0x4c, 0x56, 0x90, 0x0, 0xa, 0x56, 0x90, + 0x0, 0xa, 0x56, 0x90, 0x0, 0xa, 0x56, 0x90, + 0x0, 0xa, 0x56, 0x90, 0x0, 0xa, 0x56, 0x90, + + /* U+00B7 "·" */ + 0xe4, 0x20, + + /* U+00BB "»" */ + 0x0, 0x0, 0x0, 0xc, 0x28, 0x60, 0x3, 0xd1, + 0xd2, 0x0, 0xc6, 0x7a, 0x3, 0xc1, 0xd2, 0xc, + 0x28, 0x50, + + /* U+00BD "½" */ + 0x6, 0xc0, 0x0, 0x9, 0x50, 0x36, 0xc0, 0x0, + 0x49, 0x0, 0x1, 0xc0, 0x1, 0xc0, 0x0, 0x1, + 0xc0, 0xb, 0x30, 0x0, 0x0, 0x20, 0x77, 0x3a, + 0xb4, 0x0, 0x3, 0xb0, 0x52, 0x3b, 0x0, 0xc, + 0x10, 0x1, 0xc5, 0x0, 0xa4, 0x0, 0x1c, 0x40, + 0x4, 0x80, 0x0, 0xad, 0xda, + + /* U+0384 "΄" */ + 0x8, 0x27, 0x90, + + /* U+0386 "Ά" */ + 0x2e, 0x2e, 0xb0, 0x0, 0x4, 0x35, 0xbe, 0x20, + 0x0, 0x0, 0xb6, 0x99, 0x0, 0x0, 0x2f, 0x13, + 0xf1, 0x0, 0x8, 0xa0, 0xd, 0x70, 0x0, 0xee, + 0xee, 0xee, 0x0, 0x6d, 0x0, 0x0, 0xe5, 0xc, + 0x60, 0x0, 0x8, 0xc0, + + /* U+0388 "Έ" */ + 0xe, 0x3a, 0xff, 0xff, 0xf8, 0x35, 0xa, 0x70, + 0x0, 0x0, 0x0, 0xa, 0x70, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xf3, 0x0, 0xa, 0x70, 0x0, + 0x0, 0x0, 0xa, 0x70, 0x0, 0x0, 0x0, 0xa, + 0x70, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xfb, + + /* U+0389 "Ή" */ + 0xe, 0x3e, 0x40, 0x0, 0x4d, 0x35, 0xe, 0x40, + 0x0, 0x4d, 0x0, 0xe, 0x40, 0x0, 0x4d, 0x0, + 0xe, 0xff, 0xff, 0xfd, 0x0, 0xe, 0x40, 0x0, + 0x4d, 0x0, 0xe, 0x40, 0x0, 0x4d, 0x0, 0xe, + 0x40, 0x0, 0x4d, 0x0, 0xe, 0x40, 0x0, 0x4d, + + /* U+038A "Ί" */ + 0xe, 0x3e, 0x43, 0x50, 0xe4, 0x0, 0xe, 0x40, + 0x0, 0xe4, 0x0, 0xe, 0x40, 0x0, 0xe4, 0x0, + 0xe, 0x40, 0x0, 0xe4, + + /* U+038C "Ό" */ + 0xe, 0x47, 0xdf, 0xe9, 0x10, 0x36, 0xac, 0x20, + 0x19, 0xd0, 0x3, 0xf1, 0x0, 0x0, 0xc7, 0x6, + 0xc0, 0x0, 0x0, 0x8b, 0x7, 0xc0, 0x0, 0x0, + 0x8b, 0x3, 0xf1, 0x0, 0x0, 0xc7, 0x0, 0xac, + 0x20, 0x19, 0xd0, 0x0, 0x7, 0xde, 0xe9, 0x10, + + /* U+038E "Ύ" */ + 0xe, 0x36, 0xe1, 0x0, 0x9, 0xb0, 0x35, 0x0, + 0xba, 0x0, 0x4e, 0x10, 0x0, 0x0, 0x1e, 0x51, + 0xe4, 0x0, 0x0, 0x0, 0x4, 0xea, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x9c, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7a, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7a, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7a, 0x0, 0x0, + + /* U+038F "Ώ" */ + 0xe, 0x47, 0xdf, 0xe8, 0x0, 0x36, 0x8d, 0x30, + 0x2c, 0xa0, 0x1, 0xf3, 0x0, 0x2, 0xf2, 0x3, + 0xf0, 0x0, 0x0, 0xd5, 0x2, 0xf0, 0x0, 0x0, + 0xd4, 0x0, 0xd4, 0x0, 0x2, 0xe0, 0x0, 0x2c, + 0x20, 0x2c, 0x30, 0x5, 0xff, 0xf0, 0xdf, 0xf7, + + /* U+0390 "ΐ" */ + 0xc4, 0xba, 0x70, 0x0, 0x0, 0x3, 0xd0, 0x0, + 0x3d, 0x0, 0x3, 0xd0, 0x0, 0x3d, 0x0, 0x3, + 0xd0, 0x0, 0x3d, 0x0, + + /* U+0391 "Α" */ + 0x0, 0xe, 0xb0, 0x0, 0x0, 0x5, 0xbe, 0x20, + 0x0, 0x0, 0xb6, 0x99, 0x0, 0x0, 0x2f, 0x13, + 0xf1, 0x0, 0x8, 0xa0, 0xd, 0x70, 0x0, 0xee, + 0xee, 0xee, 0x0, 0x6d, 0x0, 0x0, 0xe5, 0xc, + 0x60, 0x0, 0x8, 0xc0, + + /* U+0392 "Β" */ + 0x1f, 0xff, 0xfc, 0x30, 0x1f, 0x0, 0x6, 0xd0, + 0x1f, 0x0, 0x6, 0xc0, 0x1f, 0xff, 0xff, 0x40, + 0x1f, 0x0, 0x5, 0xf2, 0x1f, 0x0, 0x0, 0xd5, + 0x1f, 0x0, 0x4, 0xf2, 0x1f, 0xff, 0xfd, 0x50, + + /* U+0393 "Γ" */ + 0xf, 0xff, 0xff, 0x50, 0xf1, 0x0, 0x0, 0xf, + 0x10, 0x0, 0x0, 0xf1, 0x0, 0x0, 0xf, 0x10, + 0x0, 0x0, 0xf1, 0x0, 0x0, 0xf, 0x10, 0x0, + 0x0, 0xf1, 0x0, 0x0, + + /* U+0394 "Δ" */ + 0x0, 0x0, 0xeb, 0x0, 0x0, 0x0, 0x5, 0xae, + 0x20, 0x0, 0x0, 0xc, 0x58, 0x90, 0x0, 0x0, + 0x2e, 0x1, 0xf1, 0x0, 0x0, 0x99, 0x0, 0xb7, + 0x0, 0x0, 0xf2, 0x0, 0x4e, 0x0, 0x6, 0xc0, + 0x0, 0xd, 0x50, 0xc, 0xff, 0xff, 0xff, 0xc0, + + /* U+0395 "Ε" */ + 0xf, 0xff, 0xff, 0xf2, 0xf, 0x10, 0x0, 0x0, + 0xf, 0x10, 0x0, 0x0, 0xf, 0xff, 0xff, 0xc0, + 0xf, 0x10, 0x0, 0x0, 0xf, 0x10, 0x0, 0x0, + 0xf, 0x10, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf5, + + /* U+0396 "Ζ" */ + 0x4f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x1e, 0x60, + 0x0, 0x0, 0xd8, 0x0, 0x0, 0xb, 0xa0, 0x0, + 0x0, 0x9c, 0x0, 0x0, 0x7, 0xd1, 0x0, 0x0, + 0x5e, 0x20, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf0, + + /* U+0397 "Η" */ + 0xf, 0x10, 0x0, 0x7b, 0xf, 0x10, 0x0, 0x7b, + 0xf, 0x10, 0x0, 0x7b, 0xf, 0xff, 0xff, 0xfb, + 0xf, 0x10, 0x0, 0x7b, 0xf, 0x10, 0x0, 0x7b, + 0xf, 0x10, 0x0, 0x7b, 0xf, 0x10, 0x0, 0x7b, + + /* U+0398 "Θ" */ + 0x0, 0x7d, 0xfe, 0x91, 0x0, 0x9c, 0x20, 0x19, + 0xd1, 0x2f, 0x10, 0x0, 0xb, 0x86, 0xd0, 0xff, + 0xf5, 0x7b, 0x6c, 0x0, 0x0, 0x7, 0xb2, 0xf1, + 0x0, 0x0, 0xb8, 0x9, 0xc2, 0x1, 0x8e, 0x10, + 0x7, 0xde, 0xe9, 0x10, + + /* U+0399 "Ι" */ + 0xe3, 0xe3, 0xe3, 0xe3, 0xe3, 0xe3, 0xe3, 0xe3, + + /* U+039A "Κ" */ + 0x1f, 0x0, 0x4, 0xe4, 0x1f, 0x0, 0x5e, 0x30, + 0x1f, 0x6, 0xd2, 0x0, 0x1f, 0x7f, 0x70, 0x0, + 0x1f, 0xc4, 0xf3, 0x0, 0x1f, 0x0, 0x6e, 0x10, + 0x1f, 0x0, 0xa, 0xc0, 0x1f, 0x0, 0x0, 0xd9, + + /* U+039B "Λ" */ + 0x0, 0xc, 0xc0, 0x0, 0x0, 0x3c, 0xc3, 0x0, + 0x0, 0xa6, 0x6a, 0x0, 0x1, 0xe1, 0x1f, 0x10, + 0x7, 0x90, 0xa, 0x70, 0xe, 0x30, 0x4, 0xd0, + 0x4d, 0x0, 0x0, 0xe4, 0xb6, 0x0, 0x0, 0x8b, + + /* U+039C "Μ" */ + 0x1f, 0xc0, 0x0, 0x9, 0xf1, 0x1f, 0xe2, 0x0, + 0xd, 0xf1, 0x1f, 0x88, 0x0, 0x58, 0xf1, 0x1f, + 0x2d, 0x0, 0xb2, 0xf1, 0x1f, 0xc, 0x31, 0xc0, + 0xf1, 0x1f, 0x6, 0x97, 0x70, 0xf1, 0x1f, 0x1, + 0xec, 0x10, 0xf1, 0x1f, 0x0, 0xbb, 0x0, 0xf1, + + /* U+039D "Ν" */ + 0xf, 0x70, 0x0, 0x6b, 0xf, 0xf3, 0x0, 0x6b, + 0xf, 0x7d, 0x0, 0x6b, 0xf, 0xa, 0xa0, 0x6b, + 0xf, 0x1, 0xe5, 0x6b, 0xf, 0x0, 0x4e, 0x7b, + 0xf, 0x0, 0x8, 0xfb, 0xf, 0x0, 0x0, 0xcb, + + /* U+039E "Ξ" */ + 0x3f, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf2, + + /* U+039F "Ο" */ + 0x0, 0x7d, 0xfe, 0x91, 0x0, 0x9c, 0x20, 0x19, + 0xd1, 0x2f, 0x10, 0x0, 0xb, 0x86, 0xd0, 0x0, + 0x0, 0x7b, 0x6c, 0x0, 0x0, 0x7, 0xb2, 0xf1, + 0x0, 0x0, 0xb8, 0x9, 0xc2, 0x1, 0x8e, 0x10, + 0x7, 0xde, 0xe9, 0x10, + + /* U+03A0 "Π" */ + 0xf, 0xff, 0xff, 0xfb, 0xf, 0x10, 0x0, 0x7b, + 0xf, 0x10, 0x0, 0x7b, 0xf, 0x10, 0x0, 0x7b, + 0xf, 0x10, 0x0, 0x7b, 0xf, 0x10, 0x0, 0x7b, + 0xf, 0x10, 0x0, 0x7b, 0xf, 0x10, 0x0, 0x7b, + + /* U+03A1 "Ρ" */ + 0x1f, 0xff, 0xfe, 0x70, 0x1f, 0x10, 0x2, 0xe4, + 0x1f, 0x10, 0x0, 0xb7, 0x1f, 0x10, 0x3, 0xf3, + 0x1f, 0xff, 0xfd, 0x60, 0x1f, 0x10, 0x0, 0x0, + 0x1f, 0x10, 0x0, 0x0, 0x1f, 0x10, 0x0, 0x0, + + /* U+03A3 "Σ" */ + 0x2f, 0xff, 0xff, 0xa0, 0xb9, 0x0, 0x0, 0x0, + 0xaa, 0x0, 0x0, 0x0, 0xba, 0x0, 0x0, 0x1d, + 0x70, 0x0, 0xc, 0x80, 0x0, 0xb, 0x90, 0x0, + 0x2, 0xff, 0xff, 0xfe, + + /* U+03A4 "Τ" */ + 0xbf, 0xff, 0xff, 0xf0, 0x0, 0xe, 0x30, 0x0, + 0x0, 0xe, 0x30, 0x0, 0x0, 0xe, 0x30, 0x0, + 0x0, 0xe, 0x30, 0x0, 0x0, 0xe, 0x30, 0x0, + 0x0, 0xe, 0x30, 0x0, 0x0, 0xe, 0x30, 0x0, + + /* U+03A5 "Υ" */ + 0x9c, 0x0, 0x0, 0xc8, 0xd, 0x70, 0x7, 0xc0, + 0x3, 0xf2, 0x3e, 0x10, 0x0, 0x7c, 0xd4, 0x0, + 0x0, 0xc, 0x90, 0x0, 0x0, 0xa, 0x70, 0x0, + 0x0, 0xa, 0x70, 0x0, 0x0, 0xa, 0x70, 0x0, + + /* U+03A6 "Φ" */ + 0x0, 0x0, 0xc5, 0x0, 0x0, 0x2, 0xad, 0xfe, + 0xc6, 0x0, 0x1e, 0x70, 0xc5, 0x2c, 0x90, 0x6c, + 0x0, 0xc5, 0x3, 0xf0, 0x6c, 0x0, 0xc5, 0x2, + 0xf0, 0x1e, 0x70, 0xc5, 0x2c, 0x90, 0x2, 0x9d, + 0xfe, 0xc6, 0x0, 0x0, 0x0, 0xc5, 0x0, 0x0, + 0x0, 0x0, 0x83, 0x0, 0x0, + + /* U+03A7 "Χ" */ + 0x3f, 0x30, 0x1, 0xd4, 0x6, 0xd1, 0xb, 0x70, + 0x0, 0xaa, 0x8a, 0x0, 0x0, 0xd, 0xe0, 0x0, + 0x0, 0x3e, 0xf3, 0x0, 0x1, 0xe5, 0x6e, 0x10, + 0xb, 0x90, 0x9, 0xc0, 0x8c, 0x0, 0x0, 0xd8, + + /* U+03A8 "Ψ" */ + 0x4e, 0x0, 0x99, 0x0, 0xd4, 0x4e, 0x0, 0x99, + 0x0, 0xd4, 0x3e, 0x0, 0x99, 0x0, 0xe4, 0x1f, + 0x0, 0x99, 0x1, 0xf1, 0xb, 0xa1, 0x99, 0x1a, + 0xb0, 0x1, 0x9d, 0xff, 0xd8, 0x10, 0x0, 0x0, + 0x99, 0x0, 0x0, 0x0, 0x0, 0x99, 0x0, 0x0, + + /* U+03A9 "Ω" */ + 0x0, 0x7d, 0xfe, 0x70, 0x0, 0x9d, 0x20, 0x2d, + 0x90, 0x2f, 0x20, 0x0, 0x2f, 0x14, 0xe0, 0x0, + 0x0, 0xe4, 0x3e, 0x0, 0x0, 0xe, 0x30, 0xd3, + 0x0, 0x3, 0xd0, 0x3, 0xc2, 0x2, 0xc2, 0x6, + 0xff, 0xe0, 0xef, 0xf6, + + /* U+03AA "Ϊ" */ + 0xf1, 0xc4, 0x20, 0x20, 0xe, 0x30, 0xe, 0x30, + 0xe, 0x30, 0xe, 0x30, 0xe, 0x30, 0xe, 0x30, + 0xe, 0x30, 0xe, 0x30, + + /* U+03AB "Ϋ" */ + 0x0, 0xa6, 0x79, 0x0, 0x0, 0x11, 0x11, 0x0, + 0x9c, 0x0, 0x0, 0xc8, 0xd, 0x70, 0x7, 0xc0, + 0x3, 0xf2, 0x3e, 0x10, 0x0, 0x7c, 0xd4, 0x0, + 0x0, 0xc, 0x90, 0x0, 0x0, 0xa, 0x70, 0x0, + 0x0, 0xa, 0x70, 0x0, 0x0, 0xa, 0x70, 0x0, + + /* U+03AC "ά" */ + 0x0, 0xc, 0x70, 0x0, 0x1, 0x70, 0x0, 0x7, + 0xcb, 0x7c, 0x54, 0xe0, 0x8, 0xf1, 0x8a, 0x0, + 0x3d, 0x8, 0xa0, 0x3, 0xd0, 0x3e, 0x0, 0x8f, + 0x0, 0x7c, 0xb8, 0xb5, + + /* U+03AD "έ" */ + 0x0, 0x6c, 0x0, 0x0, 0x61, 0x0, 0xa, 0xdd, + 0x60, 0x2e, 0x0, 0x10, 0xb, 0xf5, 0x0, 0x4d, + 0x0, 0x0, 0x5c, 0x1, 0x60, 0xa, 0xdd, 0x70, + + /* U+03AE "ή" */ + 0x0, 0xd, 0x60, 0x0, 0x16, 0x0, 0x3d, 0x9b, + 0xd4, 0x3f, 0x20, 0x5c, 0x3e, 0x0, 0x3d, 0x3e, + 0x0, 0x3e, 0x3e, 0x0, 0x3e, 0x3e, 0x0, 0x3e, + 0x0, 0x0, 0x3e, 0x0, 0x0, 0x3e, + + /* U+03AF "ί" */ + 0xd, 0x62, 0x60, 0x3d, 0x3, 0xd0, 0x3d, 0x3, + 0xd0, 0x3d, 0x3, 0xd0, + + /* U+03B0 "ΰ" */ + 0xd, 0x4b, 0xa6, 0x0, 0x0, 0x0, 0x3d, 0x0, + 0x4c, 0x3d, 0x0, 0x4c, 0x3d, 0x0, 0x4c, 0x3e, + 0x0, 0x4c, 0x1f, 0x20, 0x99, 0x5, 0xdd, 0xb1, + + /* U+03B1 "α" */ + 0x7, 0xcb, 0x7c, 0x54, 0xe0, 0x8, 0xf1, 0x8a, + 0x0, 0x3d, 0x8, 0xa0, 0x3, 0xd0, 0x3e, 0x0, + 0x8f, 0x0, 0x7c, 0xb8, 0xb5, + + /* U+03B2 "β" */ + 0x4, 0xcd, 0xc2, 0x0, 0xe2, 0x5, 0xb0, 0x2e, + 0x0, 0x6a, 0x2, 0xe2, 0xdd, 0x20, 0x2e, 0x0, + 0x4e, 0x12, 0xe0, 0x0, 0xc4, 0x2f, 0x30, 0x1e, + 0x22, 0xe9, 0xbc, 0x60, 0x2e, 0x0, 0x0, 0x2, + 0xe0, 0x0, 0x0, + + /* U+03B3 "γ" */ + 0xa7, 0x0, 0x6a, 0x4d, 0x0, 0xc4, 0xd, 0x33, + 0xd0, 0x7, 0x99, 0x70, 0x1, 0xee, 0x10, 0x0, + 0xaa, 0x0, 0x0, 0x88, 0x0, 0x0, 0x88, 0x0, + + /* U+03B4 "δ" */ + 0xe, 0xed, 0xd9, 0x0, 0x1a, 0x50, 0x0, 0x6, + 0xdc, 0xa1, 0x3, 0xe1, 0x4, 0xc0, 0x89, 0x0, + 0xe, 0x27, 0x90, 0x0, 0xe3, 0x3e, 0x20, 0x5e, + 0x0, 0x5d, 0xdc, 0x30, + + /* U+03B5 "ε" */ + 0xa, 0xdd, 0x60, 0x2e, 0x0, 0x10, 0xb, 0xf5, + 0x0, 0x4d, 0x0, 0x0, 0x5c, 0x1, 0x60, 0xa, + 0xdd, 0x70, + + /* U+03B6 "ζ" */ + 0x8, 0xdd, 0xf2, 0x0, 0x3b, 0x20, 0x2, 0xc1, + 0x0, 0xc, 0x30, 0x0, 0x5b, 0x0, 0x0, 0x88, + 0x0, 0x0, 0x6c, 0x30, 0x0, 0xb, 0xff, 0xa0, + 0x0, 0x2, 0xf0, 0x0, 0xc, 0x50, + + /* U+03B7 "η" */ + 0x3d, 0x9b, 0xd4, 0x3f, 0x20, 0x5c, 0x3e, 0x0, + 0x3d, 0x3e, 0x0, 0x3e, 0x3e, 0x0, 0x3e, 0x3e, + 0x0, 0x3e, 0x0, 0x0, 0x3e, 0x0, 0x0, 0x3e, + + /* U+03B8 "θ" */ + 0x3, 0xcd, 0xb1, 0x0, 0xe2, 0x6, 0xa0, 0x4b, + 0x0, 0xf, 0x6, 0xec, 0xcc, 0xf1, 0x6a, 0x0, + 0xf, 0x14, 0xd0, 0x2, 0xf0, 0xe, 0x30, 0x8a, + 0x0, 0x3c, 0xdb, 0x10, + + /* U+03B9 "ι" */ + 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, + + /* U+03BA "κ" */ + 0x3d, 0x3, 0xe4, 0x3d, 0x4d, 0x20, 0x3f, 0xf3, + 0x0, 0x3e, 0x8c, 0x0, 0x3d, 0xa, 0xb0, 0x3d, + 0x0, 0xc9, + + /* U+03BB "λ" */ + 0x4, 0xd0, 0x0, 0x0, 0xd3, 0x0, 0x0, 0xaa, + 0x0, 0x1, 0xef, 0x10, 0x7, 0xaa, 0x70, 0xd, + 0x34, 0xd0, 0x4d, 0x0, 0xd3, 0xa7, 0x0, 0x7a, + + /* U+03BC "μ" */ + 0x2d, 0x0, 0x3d, 0x2d, 0x0, 0x3d, 0x2d, 0x0, + 0x3d, 0x2e, 0x0, 0x3d, 0x2f, 0x20, 0x7d, 0x2e, + 0xbc, 0xad, 0x2d, 0x0, 0x0, 0x2d, 0x0, 0x0, + + /* U+03BD "ν" */ + 0xa7, 0x0, 0x6a, 0x4d, 0x0, 0xc4, 0xd, 0x32, + 0xd0, 0x7, 0x98, 0x70, 0x1, 0xee, 0x10, 0x0, + 0xab, 0x0, + + /* U+03BE "ξ" */ + 0x7, 0xdd, 0x70, 0x1f, 0x10, 0x0, 0x5, 0xee, + 0x60, 0xa, 0x81, 0x0, 0x4c, 0x0, 0x0, 0x6a, + 0x0, 0x0, 0x1e, 0x84, 0x0, 0x1, 0x7b, 0xd0, + 0x0, 0x1, 0xf1, 0x0, 0x1d, 0x60, + + /* U+03BF "ο" */ + 0x5, 0xdd, 0xb2, 0x3, 0xe1, 0x5, 0xd0, 0x79, + 0x0, 0xe, 0x28, 0x90, 0x0, 0xe2, 0x3e, 0x10, + 0x5d, 0x0, 0x6d, 0xdc, 0x20, + + /* U+03C0 "π" */ + 0x9d, 0xfd, 0xde, 0xed, 0x0, 0x1f, 0x0, 0x79, + 0x0, 0x1, 0xf0, 0x7, 0x90, 0x0, 0x1f, 0x0, + 0x79, 0x0, 0x1, 0xf0, 0x7, 0x90, 0x0, 0x1f, + 0x0, 0x79, 0x0, + + /* U+03C1 "ρ" */ + 0x3, 0xcd, 0xc3, 0x0, 0xe4, 0x3, 0xe1, 0x2e, + 0x0, 0xb, 0x53, 0xe0, 0x0, 0xb5, 0x3f, 0x30, + 0x2e, 0x13, 0xeb, 0xcc, 0x40, 0x3d, 0x0, 0x0, + 0x3, 0xd0, 0x0, 0x0, + + /* U+03C2 "ς" */ + 0x1, 0xac, 0xd7, 0xd, 0x50, 0x0, 0x6a, 0x0, + 0x0, 0x6a, 0x0, 0x0, 0x1d, 0x82, 0x0, 0x1, + 0x7b, 0xc1, 0x0, 0x0, 0xd5, 0x0, 0x9e, 0xa0, + + /* U+03C3 "σ" */ + 0x6, 0xdf, 0xff, 0xf2, 0x3e, 0x20, 0x7d, 0x0, + 0x89, 0x0, 0xe, 0x20, 0x88, 0x0, 0xe, 0x20, + 0x3d, 0x10, 0x5d, 0x0, 0x6, 0xdd, 0xb2, 0x0, + + /* U+03C4 "τ" */ + 0x9d, 0xfd, 0x60, 0x1f, 0x0, 0x1, 0xf0, 0x0, + 0x1f, 0x0, 0x1, 0xf0, 0x0, 0x1f, 0x0, + + /* U+03C5 "υ" */ + 0x3d, 0x0, 0x4c, 0x3d, 0x0, 0x4c, 0x3d, 0x0, + 0x4c, 0x3e, 0x0, 0x4c, 0x1f, 0x20, 0x99, 0x5, + 0xdd, 0xb1, + + /* U+03C6 "φ" */ + 0x6, 0xa4, 0xed, 0x50, 0x3d, 0x9, 0x71, 0xe1, + 0x88, 0x9, 0x70, 0xc5, 0x7a, 0x9, 0x70, 0xe3, + 0x1e, 0x49, 0x77, 0xc0, 0x3, 0xcf, 0xf9, 0x10, + 0x0, 0x9, 0x70, 0x0, 0x0, 0x9, 0x70, 0x0, + + /* U+03C7 "χ" */ + 0x7b, 0x0, 0x5c, 0x0, 0xd3, 0xe, 0x30, 0x5, + 0xc7, 0x90, 0x0, 0xc, 0xe1, 0x0, 0x0, 0xce, + 0x20, 0x0, 0x6a, 0x6b, 0x0, 0x1e, 0x20, 0xd4, + 0x9, 0x80, 0x4, 0xd0, + + /* U+03C8 "ψ" */ + 0x4c, 0x4, 0xd0, 0x3d, 0x4c, 0x4, 0xd0, 0x3d, + 0x4c, 0x4, 0xd0, 0x3d, 0x4c, 0x4, 0xd0, 0x4c, + 0x1f, 0x24, 0xd0, 0x99, 0x4, 0xcd, 0xfd, 0xa1, + 0x0, 0x4, 0xd0, 0x0, 0x0, 0x4, 0xd0, 0x0, + + /* U+03C9 "ω" */ + 0xc, 0x40, 0x0, 0xd, 0x23, 0xd0, 0x6, 0x10, + 0x89, 0x6a, 0x0, 0xd3, 0x4, 0xc6, 0x90, 0xd, + 0x30, 0x4c, 0x3e, 0x2, 0xe7, 0x9, 0x90, 0x7d, + 0xc3, 0xac, 0xb1, + + /* U+03CA "ϊ" */ + 0x5c, 0x2f, 0x1, 0x2, 0x3, 0xd0, 0x3, 0xd0, + 0x3, 0xd0, 0x3, 0xd0, 0x3, 0xd0, 0x3, 0xd0, + + /* U+03CB "ϋ" */ + 0x5, 0xc2, 0xe0, 0x0, 0x10, 0x20, 0x3d, 0x0, + 0x4c, 0x3d, 0x0, 0x4c, 0x3d, 0x0, 0x4c, 0x3e, + 0x0, 0x4c, 0x1f, 0x20, 0x99, 0x5, 0xdd, 0xb1, + + /* U+03CC "ό" */ + 0x0, 0xd, 0x60, 0x0, 0x1, 0x60, 0x0, 0x5, + 0xdd, 0xb2, 0x3, 0xe1, 0x5, 0xd0, 0x79, 0x0, + 0xe, 0x28, 0x90, 0x0, 0xe2, 0x3e, 0x10, 0x5d, + 0x0, 0x6d, 0xdc, 0x20, + + /* U+03CD "ύ" */ + 0x0, 0xd, 0x50, 0x0, 0x26, 0x0, 0x3d, 0x0, + 0x4c, 0x3d, 0x0, 0x4c, 0x3d, 0x0, 0x4c, 0x3e, + 0x0, 0x4c, 0x1f, 0x20, 0x99, 0x5, 0xdd, 0xb1, + + /* U+03CE "ώ" */ + 0x0, 0x0, 0x7b, 0x0, 0x0, 0x0, 0x7, 0x0, + 0x0, 0xc, 0x40, 0x0, 0xd, 0x23, 0xd0, 0x6, + 0x10, 0x89, 0x6a, 0x0, 0xd3, 0x4, 0xc6, 0x90, + 0xd, 0x30, 0x4c, 0x3e, 0x2, 0xe7, 0x9, 0x90, + 0x7d, 0xc3, 0xac, 0xb1, + + /* U+03F4 "ϴ" */ + 0x2e, 0x59, 0xe2, 0x0, 0x0, 0x0 +}; + + +/*--------------------- + * GLYPH DESCRIPTION + *--------------------*/ + +static const lv_font_fmt_txt_glyph_dsc_t glyph_dsc[] = { + {.bitmap_index = 0, .adv_w = 0, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0} /* id = 0 reserved */, + {.bitmap_index = 0, .adv_w = 53, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 0, .adv_w = 54, .box_w = 2, .box_h = 8, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 8, .adv_w = 68, .box_w = 4, .box_h = 3, .ofs_x = 0, .ofs_y = 5}, + {.bitmap_index = 14, .adv_w = 107, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 42, .adv_w = 107, .box_w = 7, .box_h = 10, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 77, .adv_w = 171, .box_w = 10, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 117, .adv_w = 128, .box_w = 8, .box_h = 9, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 153, .adv_w = 36, .box_w = 2, .box_h = 3, .ofs_x = 0, .ofs_y = 5}, + {.bitmap_index = 156, .adv_w = 64, .box_w = 4, .box_h = 10, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 176, .adv_w = 64, .box_w = 4, .box_h = 10, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 196, .adv_w = 75, .box_w = 5, .box_h = 4, .ofs_x = 0, .ofs_y = 4}, + {.bitmap_index = 206, .adv_w = 112, .box_w = 7, .box_h = 6, .ofs_x = 0, .ofs_y = 1}, + {.bitmap_index = 227, .adv_w = 54, .box_w = 3, .box_h = 4, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 233, .adv_w = 64, .box_w = 4, .box_h = 1, .ofs_x = 0, .ofs_y = 2}, + {.bitmap_index = 235, .adv_w = 54, .box_w = 2, .box_h = 2, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 237, .adv_w = 53, .box_w = 4, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 253, .adv_w = 107, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 281, .adv_w = 107, .box_w = 4, .box_h = 8, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 297, .adv_w = 107, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 325, .adv_w = 107, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 353, .adv_w = 107, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 381, .adv_w = 107, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 409, .adv_w = 107, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 437, .adv_w = 107, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 465, .adv_w = 107, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 493, .adv_w = 107, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 521, .adv_w = 54, .box_w = 2, .box_h = 6, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 527, .adv_w = 54, .box_w = 3, .box_h = 8, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 539, .adv_w = 112, .box_w = 7, .box_h = 6, .ofs_x = 0, .ofs_y = 1}, + {.bitmap_index = 560, .adv_w = 112, .box_w = 7, .box_h = 3, .ofs_x = 0, .ofs_y = 3}, + {.bitmap_index = 571, .adv_w = 112, .box_w = 7, .box_h = 6, .ofs_x = 0, .ofs_y = 1}, + {.bitmap_index = 592, .adv_w = 107, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 620, .adv_w = 195, .box_w = 12, .box_h = 10, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 680, .adv_w = 128, .box_w = 9, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 716, .adv_w = 128, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 748, .adv_w = 139, .box_w = 9, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 784, .adv_w = 139, .box_w = 9, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 820, .adv_w = 128, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 852, .adv_w = 118, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 880, .adv_w = 149, .box_w = 9, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 916, .adv_w = 139, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 948, .adv_w = 54, .box_w = 2, .box_h = 8, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 956, .adv_w = 96, .box_w = 6, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 980, .adv_w = 128, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1012, .adv_w = 107, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1040, .adv_w = 160, .box_w = 10, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1080, .adv_w = 139, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1112, .adv_w = 149, .box_w = 9, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1148, .adv_w = 128, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1180, .adv_w = 149, .box_w = 9, .box_h = 9, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 1221, .adv_w = 139, .box_w = 9, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1257, .adv_w = 128, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1289, .adv_w = 118, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1321, .adv_w = 139, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1353, .adv_w = 128, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1385, .adv_w = 181, .box_w = 12, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1433, .adv_w = 128, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1465, .adv_w = 128, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1497, .adv_w = 118, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1529, .adv_w = 54, .box_w = 4, .box_h = 10, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 1549, .adv_w = 53, .box_w = 4, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1565, .adv_w = 54, .box_w = 3, .box_h = 10, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 1580, .adv_w = 90, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 4}, + {.bitmap_index = 1595, .adv_w = 107, .box_w = 8, .box_h = 1, .ofs_x = -1, .ofs_y = -2}, + {.bitmap_index = 1599, .adv_w = 64, .box_w = 3, .box_h = 2, .ofs_x = 0, .ofs_y = 7}, + {.bitmap_index = 1602, .adv_w = 107, .box_w = 7, .box_h = 6, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1623, .adv_w = 107, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1651, .adv_w = 96, .box_w = 6, .box_h = 6, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1669, .adv_w = 107, .box_w = 6, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1693, .adv_w = 107, .box_w = 7, .box_h = 6, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1714, .adv_w = 54, .box_w = 4, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1730, .adv_w = 107, .box_w = 6, .box_h = 8, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 1754, .adv_w = 107, .box_w = 6, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1778, .adv_w = 43, .box_w = 2, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1786, .adv_w = 43, .box_w = 3, .box_h = 10, .ofs_x = -1, .ofs_y = -2}, + {.bitmap_index = 1801, .adv_w = 96, .box_w = 6, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1825, .adv_w = 43, .box_w = 2, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1833, .adv_w = 160, .box_w = 10, .box_h = 6, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1863, .adv_w = 107, .box_w = 6, .box_h = 6, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1881, .adv_w = 107, .box_w = 7, .box_h = 6, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1902, .adv_w = 107, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 1930, .adv_w = 107, .box_w = 6, .box_h = 8, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 1954, .adv_w = 64, .box_w = 5, .box_h = 6, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1969, .adv_w = 96, .box_w = 6, .box_h = 6, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1987, .adv_w = 54, .box_w = 4, .box_h = 9, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2005, .adv_w = 107, .box_w = 6, .box_h = 6, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2023, .adv_w = 96, .box_w = 6, .box_h = 6, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2041, .adv_w = 139, .box_w = 9, .box_h = 6, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2068, .adv_w = 96, .box_w = 6, .box_h = 6, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2086, .adv_w = 96, .box_w = 6, .box_h = 8, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 2110, .adv_w = 96, .box_w = 6, .box_h = 6, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2128, .adv_w = 64, .box_w = 4, .box_h = 10, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 2148, .adv_w = 50, .box_w = 2, .box_h = 10, .ofs_x = 1, .ofs_y = -2}, + {.bitmap_index = 2158, .adv_w = 64, .box_w = 4, .box_h = 10, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 2178, .adv_w = 112, .box_w = 7, .box_h = 3, .ofs_x = 0, .ofs_y = 2}, + {.bitmap_index = 2189, .adv_w = 53, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2189, .adv_w = 107, .box_w = 7, .box_h = 9, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 2221, .adv_w = 107, .box_w = 7, .box_h = 7, .ofs_x = 0, .ofs_y = 1}, + {.bitmap_index = 2246, .adv_w = 107, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2274, .adv_w = 50, .box_w = 2, .box_h = 10, .ofs_x = 1, .ofs_y = -2}, + {.bitmap_index = 2284, .adv_w = 107, .box_w = 7, .box_h = 10, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 2319, .adv_w = 64, .box_w = 4, .box_h = 2, .ofs_x = 0, .ofs_y = 6}, + {.bitmap_index = 2323, .adv_w = 141, .box_w = 9, .box_h = 9, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2364, .adv_w = 72, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 4}, + {.bitmap_index = 2377, .adv_w = 107, .box_w = 6, .box_h = 6, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2395, .adv_w = 112, .box_w = 7, .box_h = 4, .ofs_x = 0, .ofs_y = 2}, + {.bitmap_index = 2409, .adv_w = 64, .box_w = 4, .box_h = 1, .ofs_x = 0, .ofs_y = 2}, + {.bitmap_index = 2411, .adv_w = 141, .box_w = 9, .box_h = 9, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2452, .adv_w = 77, .box_w = 5, .box_h = 3, .ofs_x = 0, .ofs_y = 5}, + {.bitmap_index = 2460, .adv_w = 112, .box_w = 7, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2485, .adv_w = 64, .box_w = 4, .box_h = 5, .ofs_x = 0, .ofs_y = 4}, + {.bitmap_index = 2495, .adv_w = 64, .box_w = 4, .box_h = 5, .ofs_x = 0, .ofs_y = 4}, + {.bitmap_index = 2505, .adv_w = 107, .box_w = 6, .box_h = 8, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 2529, .adv_w = 103, .box_w = 8, .box_h = 10, .ofs_x = -1, .ofs_y = -2}, + {.bitmap_index = 2569, .adv_w = 54, .box_w = 2, .box_h = 2, .ofs_x = 1, .ofs_y = 3}, + {.bitmap_index = 2571, .adv_w = 107, .box_w = 6, .box_h = 6, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2589, .adv_w = 160, .box_w = 10, .box_h = 9, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2634, .adv_w = 64, .box_w = 3, .box_h = 2, .ofs_x = 1, .ofs_y = 7}, + {.bitmap_index = 2637, .adv_w = 128, .box_w = 9, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2673, .adv_w = 151, .box_w = 10, .box_h = 8, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 2713, .adv_w = 161, .box_w = 10, .box_h = 8, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 2753, .adv_w = 74, .box_w = 5, .box_h = 8, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 2773, .adv_w = 149, .box_w = 10, .box_h = 8, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 2813, .adv_w = 164, .box_w = 12, .box_h = 8, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 2861, .adv_w = 144, .box_w = 10, .box_h = 8, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 2901, .adv_w = 43, .box_w = 5, .box_h = 8, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 2921, .adv_w = 128, .box_w = 9, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2957, .adv_w = 128, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2989, .adv_w = 106, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3017, .adv_w = 128, .box_w = 10, .box_h = 8, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 3057, .adv_w = 128, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3089, .adv_w = 118, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3121, .adv_w = 139, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3153, .adv_w = 149, .box_w = 9, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3189, .adv_w = 54, .box_w = 2, .box_h = 8, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3197, .adv_w = 128, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3229, .adv_w = 128, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3261, .adv_w = 160, .box_w = 10, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3301, .adv_w = 139, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3333, .adv_w = 125, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3365, .adv_w = 149, .box_w = 9, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3401, .adv_w = 139, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3433, .adv_w = 128, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3465, .adv_w = 119, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3493, .adv_w = 118, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3525, .adv_w = 128, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3557, .adv_w = 153, .box_w = 10, .box_h = 9, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 3602, .adv_w = 128, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3634, .adv_w = 160, .box_w = 10, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3674, .adv_w = 144, .box_w = 9, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3710, .adv_w = 54, .box_w = 4, .box_h = 10, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3730, .adv_w = 128, .box_w = 8, .box_h = 10, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3770, .adv_w = 111, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3798, .adv_w = 86, .box_w = 6, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3822, .adv_w = 107, .box_w = 6, .box_h = 10, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 3852, .adv_w = 43, .box_w = 3, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3864, .adv_w = 105, .box_w = 6, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3888, .adv_w = 111, .box_w = 7, .box_h = 6, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3909, .adv_w = 110, .box_w = 7, .box_h = 10, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 3944, .adv_w = 96, .box_w = 6, .box_h = 8, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 3968, .adv_w = 107, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3996, .adv_w = 86, .box_w = 6, .box_h = 6, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4014, .adv_w = 85, .box_w = 6, .box_h = 10, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 4044, .adv_w = 107, .box_w = 6, .box_h = 8, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 4068, .adv_w = 107, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4096, .adv_w = 43, .box_w = 2, .box_h = 6, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4102, .adv_w = 96, .box_w = 6, .box_h = 6, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4120, .adv_w = 96, .box_w = 6, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4144, .adv_w = 107, .box_w = 6, .box_h = 8, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 4168, .adv_w = 96, .box_w = 6, .box_h = 6, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4186, .adv_w = 86, .box_w = 6, .box_h = 10, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 4216, .adv_w = 107, .box_w = 7, .box_h = 6, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4237, .adv_w = 132, .box_w = 9, .box_h = 6, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4264, .adv_w = 109, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 4292, .adv_w = 93, .box_w = 6, .box_h = 8, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 4316, .adv_w = 119, .box_w = 8, .box_h = 6, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4340, .adv_w = 76, .box_w = 5, .box_h = 6, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4355, .adv_w = 105, .box_w = 6, .box_h = 6, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4373, .adv_w = 125, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 4405, .adv_w = 101, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 4433, .adv_w = 137, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 4465, .adv_w = 150, .box_w = 9, .box_h = 6, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4492, .adv_w = 43, .box_w = 4, .box_h = 8, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 4508, .adv_w = 105, .box_w = 6, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4532, .adv_w = 107, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4560, .adv_w = 105, .box_w = 6, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4584, .adv_w = 150, .box_w = 9, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4620, .adv_w = 64, .box_w = 6, .box_h = 2, .ofs_x = -1, .ofs_y = 6} +}; + +/*--------------------- + * CHARACTER MAPPING + *--------------------*/ + +static const uint8_t glyph_id_ofs_list_1[] = { + 0, 0, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 0, + 13, 14, 15, 16, 0, 17, 18, 19, + 0, 0, 0, 20, 0, 21 +}; + +static const uint8_t glyph_id_ofs_list_2[] = { + 0, 0, 1, 0, 2, 3, 4, 0, + 5 +}; + +/*Collect the unicode lists and glyph_id offsets*/ +static const lv_font_fmt_txt_cmap_t cmaps[] = +{ + { + .range_start = 32, .range_length = 95, .glyph_id_start = 1, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 160, .range_length = 30, .glyph_id_start = 96, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_1, .list_length = 30, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 900, .range_length = 9, .glyph_id_start = 118, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_2, .list_length = 9, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 910, .range_length = 20, .glyph_id_start = 124, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 931, .range_length = 44, .glyph_id_start = 144, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 1012, .range_length = 1, .glyph_id_start = 188, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + } +}; + + + +/*-------------------- + * ALL CUSTOM DATA + *--------------------*/ + +#if LVGL_VERSION_MAJOR == 8 +/*Store all the custom data of the font*/ +static lv_font_fmt_txt_glyph_cache_t cache; +#endif + +#if LVGL_VERSION_MAJOR >= 8 +static const lv_font_fmt_txt_dsc_t font_dsc = { +#else +static lv_font_fmt_txt_dsc_t font_dsc = { +#endif + .glyph_bitmap = glyph_bitmap, + .glyph_dsc = glyph_dsc, + .cmaps = cmaps, + .kern_dsc = NULL, + .kern_scale = 0, + .cmap_num = 6, + .bpp = 4, + .kern_classes = 0, + .bitmap_format = 0, +#if LVGL_VERSION_MAJOR == 8 + .cache = &cache +#endif + +}; + +extern const lv_font_t lv_font_montserrat_12; + + +/*----------------- + * PUBLIC FONT + *----------------*/ + +/*Initialize a public general font descriptor*/ +#if LVGL_VERSION_MAJOR >= 8 +const lv_font_t lv_font_arial_12 = { +#else +lv_font_t lv_font_arial_12 = { +#endif + .get_glyph_dsc = lv_font_get_glyph_dsc_fmt_txt, /*Function pointer to get glyph's data*/ + .get_glyph_bitmap = lv_font_get_bitmap_fmt_txt, /*Function pointer to get glyph's bitmap*/ + .line_height = 12, /*The maximum line height required by the font*/ + .base_line = 2, /*Baseline measured from the bottom of the line*/ +#if !(LVGL_VERSION_MAJOR == 6 && LVGL_VERSION_MINOR == 0) + .subpx = LV_FONT_SUBPX_NONE, +#endif +#if LV_VERSION_CHECK(7, 4, 0) || LVGL_VERSION_MAJOR >= 8 + .underline_position = -1, + .underline_thickness = 1, +#endif + //.static_bitmap = 0, + .dsc = &font_dsc, /*The custom font data. Will be accessed by `get_glyph_bitmap/dsc` */ +#if LV_VERSION_CHECK(8, 2, 0) || LVGL_VERSION_MAJOR >= 9 + .fallback = &lv_font_montserrat_12, +#endif + .user_data = NULL, +}; + + + +#endif /*#if LV_FONT_ARIAL_12*/ diff --git a/src/fonts/lv_font_arial_14.c b/src/fonts/lv_font_arial_14.c new file mode 100644 index 0000000000..97153aa6c6 --- /dev/null +++ b/src/fonts/lv_font_arial_14.c @@ -0,0 +1,1687 @@ +/******************************************************************************* + * Size: 14 px + * Bpp: 4 + * Opts: --bpp 4 --size 14 --no-compress --stride 1 --align 1 --font Arial Greek Regular.ttf --range 32-127,160-255,880-1023 --format lvgl -o lv_font_arial_14.c + ******************************************************************************/ + +#ifdef __has_include + #if __has_include("lvgl.h") + #ifndef LV_LVGL_H_INCLUDE_SIMPLE + #define LV_LVGL_H_INCLUDE_SIMPLE + #endif + #endif +#endif + +#ifdef LV_LVGL_H_INCLUDE_SIMPLE + #include "lvgl.h" +#else + #include "lvgl/lvgl.h" +#endif + + + +#ifndef LV_FONT_ARIAL_14 +#define LV_FONT_ARIAL_14 1 +#endif + +#if LV_FONT_ARIAL_14 + +/*----------------- + * BITMAPS + *----------------*/ + +/*Store the image of the glyphs*/ +static LV_ATTRIBUTE_LARGE_CONST const uint8_t glyph_bitmap[] = { + /* U+0020 " " */ + + /* U+0021 "!" */ + 0xdb, 0xdb, 0xcb, 0xba, 0xa9, 0x98, 0x87, 0x76, + 0x0, 0x65, 0xca, + + /* U+0022 "\"" */ + 0x5f, 0x2f, 0x55, 0xf1, 0xf5, 0x3f, 0xf, 0x31, + 0xa0, 0xa0, + + /* U+0023 "#" */ + 0x0, 0x4c, 0x1, 0xf0, 0x0, 0x78, 0x4, 0xb0, + 0x0, 0xa5, 0x7, 0x80, 0xdf, 0xff, 0xff, 0xfa, + 0x12, 0xf1, 0x1d, 0x30, 0x3, 0xd0, 0xf, 0x0, + 0x6, 0xa0, 0x3d, 0x0, 0xcf, 0xff, 0xff, 0xf9, + 0x1c, 0x52, 0xa8, 0x21, 0xf, 0x10, 0xc3, 0x0, + 0x2d, 0x0, 0xf0, 0x0, + + /* U+0024 "$" */ + 0x0, 0x1a, 0x70, 0x0, 0x6, 0xfe, 0xee, 0x20, + 0x1f, 0x57, 0x3b, 0xa0, 0x3f, 0x7, 0x33, 0x50, + 0x1f, 0x47, 0x30, 0x0, 0x9, 0xfd, 0x70, 0x0, + 0x0, 0x5c, 0xfe, 0x30, 0x0, 0x7, 0x4a, 0xd0, + 0x14, 0x7, 0x32, 0xf1, 0x5f, 0x7, 0x33, 0xf0, + 0x1e, 0xa9, 0x6c, 0xa0, 0x3, 0xcf, 0xfa, 0x10, + 0x0, 0x7, 0x30, 0x0, 0x0, 0x3, 0x10, 0x0, + + /* U+0025 "%" */ + 0x5, 0xed, 0x40, 0x0, 0xc3, 0x0, 0xf, 0x22, + 0xe0, 0x4, 0xb0, 0x0, 0x1f, 0x0, 0xf1, 0xc, + 0x30, 0x0, 0xf, 0x23, 0xe0, 0x4b, 0x0, 0x0, + 0x5, 0xdd, 0x40, 0xc3, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xb0, 0xae, 0x90, 0x0, 0x0, 0xc, 0x36, + 0xb0, 0xc5, 0x0, 0x0, 0x4b, 0x9, 0x60, 0x78, + 0x0, 0x0, 0xc3, 0x9, 0x60, 0x78, 0x0, 0x4, + 0xb0, 0x6, 0xa0, 0xc5, 0x0, 0xc, 0x30, 0x0, + 0xae, 0x90, + + /* U+0026 "&" */ + 0x0, 0x3d, 0xfa, 0x0, 0x0, 0x0, 0xe8, 0x2d, + 0x70, 0x0, 0x1, 0xf3, 0xa, 0x90, 0x0, 0x0, + 0xcb, 0x3f, 0x40, 0x0, 0x0, 0x4f, 0xf5, 0x0, + 0x0, 0x3, 0xec, 0xf4, 0x1, 0x0, 0x1e, 0x80, + 0xae, 0x4f, 0x30, 0x5f, 0x0, 0xd, 0xfd, 0x0, + 0x4f, 0x10, 0x5, 0xfa, 0x0, 0xd, 0xc3, 0x5e, + 0xcf, 0x70, 0x2, 0xbf, 0xe8, 0x7, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0027 "'" */ + 0x5f, 0x5, 0xf0, 0x4e, 0x1, 0x90, + + /* U+0028 "(" */ + 0x0, 0x1c, 0x0, 0xa, 0x60, 0x2, 0xe0, 0x0, + 0x8a, 0x0, 0xd, 0x60, 0x0, 0xf3, 0x0, 0x1f, + 0x20, 0x1, 0xf2, 0x0, 0xf, 0x30, 0x0, 0xd6, + 0x0, 0x8, 0xa0, 0x0, 0x2e, 0x0, 0x0, 0xa6, + 0x0, 0x1, 0xc0, + + /* U+0029 ")" */ + 0x3b, 0x0, 0xb, 0x40, 0x5, 0xc0, 0x0, 0xf3, + 0x0, 0xb7, 0x0, 0x9a, 0x0, 0x7c, 0x0, 0x7c, + 0x0, 0x9a, 0x0, 0xc7, 0x0, 0xf2, 0x5, 0xc0, + 0xb, 0x40, 0x3b, 0x0, + + /* U+002A "*" */ + 0x0, 0xc2, 0x4, 0x9c, 0x79, 0x17, 0xfb, 0x40, + 0xa8, 0xe2, 0x5, 0x4, 0x10, + + /* U+002B "+" */ + 0x0, 0x1, 0x10, 0x0, 0x0, 0x8, 0xa0, 0x0, + 0x0, 0x8, 0xa0, 0x0, 0x0, 0x8, 0xa0, 0x0, + 0x3f, 0xff, 0xff, 0xf6, 0x3, 0x39, 0xb3, 0x31, + 0x0, 0x8, 0xa0, 0x0, 0x0, 0x8, 0xa0, 0x0, + + /* U+002C "," */ + 0x65, 0xca, 0x29, 0x93, 0x0, + + /* U+002D "-" */ + 0x1, 0x11, 0x9, 0xff, 0xf3, 0x24, 0x44, 0x0, + + /* U+002E "." */ + 0x65, 0xca, + + /* U+002F "/" */ + 0x0, 0x3c, 0x0, 0x77, 0x0, 0xc3, 0x0, 0xe0, + 0x4, 0xb0, 0x8, 0x60, 0xd, 0x20, 0x1e, 0x0, + 0x5a, 0x0, 0x96, 0x0, 0xd1, 0x0, + + /* U+0030 "0" */ + 0x0, 0xaf, 0xe7, 0x0, 0x9, 0xd3, 0x4f, 0x50, + 0xf, 0x30, 0x7, 0xc0, 0x3f, 0x0, 0x4, 0xf0, + 0x5e, 0x0, 0x2, 0xf1, 0x6e, 0x0, 0x2, 0xf2, + 0x5e, 0x0, 0x2, 0xf1, 0x3f, 0x0, 0x4, 0xf0, + 0xf, 0x30, 0x7, 0xc0, 0x9, 0xd3, 0x4f, 0x50, + 0x0, 0xaf, 0xe7, 0x0, + + /* U+0031 "1" */ + 0x0, 0xd, 0x40, 0xa, 0xf4, 0x2c, 0xcf, 0x46, + 0x80, 0xf4, 0x0, 0xf, 0x40, 0x0, 0xf4, 0x0, + 0xf, 0x40, 0x0, 0xf4, 0x0, 0xf, 0x40, 0x0, + 0xf4, 0x0, 0xf, 0x40, + + /* U+0032 "2" */ + 0x1, 0xae, 0xe9, 0x0, 0xc, 0xb2, 0x3d, 0x90, + 0x3f, 0x10, 0x5, 0xf0, 0x3, 0x0, 0x5, 0xf0, + 0x0, 0x0, 0xb, 0xb0, 0x0, 0x0, 0x8f, 0x20, + 0x0, 0x8, 0xf4, 0x0, 0x0, 0x9f, 0x40, 0x0, + 0x7, 0xf3, 0x0, 0x0, 0x2f, 0x94, 0x44, 0x40, + 0x8f, 0xff, 0xff, 0xf1, + + /* U+0033 "3" */ + 0x1, 0xaf, 0xd5, 0x0, 0xb, 0xb2, 0x5f, 0x30, + 0x1f, 0x20, 0xa, 0x90, 0x2, 0x0, 0xa, 0xa0, + 0x0, 0x0, 0x5f, 0x40, 0x0, 0xe, 0xfb, 0x10, + 0x0, 0x0, 0x2c, 0xc0, 0x0, 0x0, 0x3, 0xf1, + 0x3e, 0x0, 0x4, 0xf0, 0xd, 0xa2, 0x4d, 0xa0, + 0x2, 0xbf, 0xe8, 0x0, + + /* U+0034 "4" */ + 0x0, 0x0, 0x8c, 0x0, 0x0, 0x3, 0xfc, 0x0, + 0x0, 0xd, 0xcc, 0x0, 0x0, 0x8a, 0x7c, 0x0, + 0x2, 0xe1, 0x7c, 0x0, 0xc, 0x60, 0x7c, 0x0, + 0x7b, 0x0, 0x7c, 0x0, 0xcf, 0xff, 0xff, 0xf2, + 0x23, 0x33, 0x8d, 0x30, 0x0, 0x0, 0x7c, 0x0, + 0x0, 0x0, 0x7c, 0x0, + + /* U+0035 "5" */ + 0x4, 0xff, 0xff, 0xc0, 0x7, 0xc4, 0x44, 0x30, + 0x9, 0x90, 0x0, 0x0, 0xc, 0x60, 0x0, 0x0, + 0xe, 0xad, 0xe9, 0x0, 0x1f, 0xa4, 0x5d, 0xb0, + 0x1, 0x0, 0x4, 0xf1, 0x0, 0x0, 0x1, 0xf3, + 0x3f, 0x10, 0x4, 0xf0, 0xe, 0xa2, 0x4d, 0x80, + 0x2, 0xbf, 0xe9, 0x0, + + /* U+0036 "6" */ + 0x0, 0x8e, 0xea, 0x0, 0x7, 0xd3, 0x3d, 0x90, + 0xf, 0x50, 0x4, 0xc0, 0x3f, 0x0, 0x0, 0x0, + 0x5e, 0x5d, 0xe9, 0x0, 0x6f, 0xd4, 0x4d, 0xa0, + 0x6f, 0x30, 0x4, 0xf0, 0x4f, 0x0, 0x1, 0xf2, + 0x1f, 0x30, 0x4, 0xf0, 0x9, 0xd3, 0x3d, 0x90, + 0x0, 0x9e, 0xfa, 0x0, + + /* U+0037 "7" */ + 0x5f, 0xff, 0xff, 0xf2, 0x14, 0x44, 0x4b, 0xc0, + 0x0, 0x0, 0x3f, 0x20, 0x0, 0x0, 0xc9, 0x0, + 0x0, 0x4, 0xf1, 0x0, 0x0, 0xb, 0xa0, 0x0, + 0x0, 0x1f, 0x40, 0x0, 0x0, 0x5e, 0x0, 0x0, + 0x0, 0x9b, 0x0, 0x0, 0x0, 0xb8, 0x0, 0x0, + 0x0, 0xd6, 0x0, 0x0, + + /* U+0038 "8" */ + 0x1, 0xae, 0xe8, 0x0, 0xa, 0xc2, 0x4e, 0x70, + 0xf, 0x40, 0x8, 0xb0, 0xd, 0xa0, 0x1c, 0x80, + 0x4, 0xef, 0xfc, 0x0, 0x7, 0xb3, 0x4e, 0x80, + 0x2f, 0x10, 0x4, 0xf0, 0x5e, 0x0, 0x1, 0xf2, + 0x4f, 0x10, 0x4, 0xf0, 0xd, 0xb2, 0x3d, 0x90, + 0x1, 0xae, 0xe8, 0x0, + + /* U+0039 "9" */ + 0x1, 0xbf, 0xe6, 0x0, 0xc, 0xc3, 0x4e, 0x60, + 0x3f, 0x20, 0x6, 0xd0, 0x5e, 0x0, 0x3, 0xf1, + 0x4f, 0x0, 0x5, 0xf2, 0xe, 0xa1, 0x2c, 0xf3, + 0x3, 0xef, 0xe6, 0xf2, 0x0, 0x1, 0x3, 0xf0, + 0x1b, 0x0, 0x8, 0xc0, 0xd, 0x92, 0x5f, 0x40, + 0x2, 0xbf, 0xd5, 0x0, + + /* U+003A ":" */ + 0xca, 0x65, 0x0, 0x0, 0x0, 0x0, 0x65, 0xca, + + /* U+003B ";" */ + 0xca, 0x65, 0x0, 0x0, 0x0, 0x0, 0x65, 0xca, + 0x29, 0x93, 0x0, + + /* U+003C "<" */ + 0x0, 0x0, 0x2, 0x95, 0x0, 0x3, 0xaf, 0xb2, + 0x4, 0xcf, 0xa3, 0x0, 0x3f, 0xa1, 0x0, 0x0, + 0x19, 0xfb, 0x40, 0x0, 0x0, 0x18, 0xfd, 0x60, + 0x0, 0x0, 0x7, 0xe6, 0x0, 0x0, 0x0, 0x1, + + /* U+003D "=" */ + 0x3f, 0xff, 0xff, 0xf6, 0x4, 0x44, 0x44, 0x41, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf6, + 0x3, 0x33, 0x33, 0x31, + + /* U+003E ">" */ + 0x3a, 0x30, 0x0, 0x0, 0x1a, 0xfb, 0x40, 0x0, + 0x0, 0x28, 0xfd, 0x60, 0x0, 0x0, 0x8, 0xf6, + 0x0, 0x3, 0xaf, 0xb2, 0x4, 0xcf, 0x92, 0x0, + 0x3f, 0x81, 0x0, 0x0, 0x10, 0x0, 0x0, 0x0, + + /* U+003F "?" */ + 0x1, 0xae, 0xe9, 0x0, 0xc, 0xb2, 0x3d, 0xa0, + 0x3f, 0x10, 0x4, 0xf0, 0x3, 0x0, 0x4, 0xf0, + 0x0, 0x0, 0x1d, 0xa0, 0x0, 0x0, 0xcc, 0x0, + 0x0, 0x7, 0xd0, 0x0, 0x0, 0xb, 0x80, 0x0, + 0x0, 0x4, 0x20, 0x0, 0x0, 0x6, 0x40, 0x0, + 0x0, 0xd, 0x90, 0x0, + + /* U+0040 "@" */ + 0x0, 0x0, 0x5b, 0xef, 0xeb, 0x40, 0x0, 0x0, + 0xa, 0xe7, 0x21, 0x27, 0xe9, 0x0, 0x0, 0x9c, + 0x10, 0x0, 0x0, 0x1d, 0x60, 0x3, 0xe1, 0x7, + 0xee, 0x4d, 0x52, 0xe0, 0xa, 0x60, 0x8d, 0x33, + 0xdf, 0x20, 0xc4, 0xf, 0x11, 0xf4, 0x0, 0x7f, + 0x0, 0xa6, 0x2e, 0x7, 0xd0, 0x0, 0x6c, 0x0, + 0xb5, 0x2d, 0x9, 0xb0, 0x0, 0x99, 0x0, 0xf1, + 0x1f, 0x8, 0xc0, 0x1, 0xf6, 0x8, 0xa0, 0xe, + 0x33, 0xf7, 0x4c, 0xf8, 0x8e, 0x10, 0x9, 0xa0, + 0x6e, 0xd4, 0xbf, 0xb1, 0x11, 0x1, 0xe7, 0x0, + 0x0, 0x0, 0x3, 0xe4, 0x0, 0x2d, 0xc6, 0x31, + 0x24, 0xaf, 0x50, 0x0, 0x0, 0x6b, 0xef, 0xec, + 0x71, 0x0, + + /* U+0041 "A" */ + 0x0, 0x5, 0xf7, 0x0, 0x0, 0x0, 0xa, 0xdd, + 0x0, 0x0, 0x0, 0xf, 0x5f, 0x30, 0x0, 0x0, + 0x6f, 0xd, 0x90, 0x0, 0x0, 0xba, 0x8, 0xe0, + 0x0, 0x1, 0xf5, 0x3, 0xf5, 0x0, 0x6, 0xf1, + 0x0, 0xeb, 0x0, 0xc, 0xff, 0xff, 0xff, 0x10, + 0x2f, 0x72, 0x22, 0x4f, 0x70, 0x7f, 0x0, 0x0, + 0xc, 0xd0, 0xd9, 0x0, 0x0, 0x5, 0xf3, + + /* U+0042 "B" */ + 0xff, 0xff, 0xe9, 0x10, 0xf8, 0x44, 0x6d, 0xb0, + 0xf5, 0x0, 0x4, 0xf0, 0xf5, 0x0, 0x3, 0xf0, + 0xf6, 0x0, 0x2b, 0xb0, 0xff, 0xff, 0xff, 0x30, + 0xf8, 0x33, 0x5a, 0xf2, 0xf5, 0x0, 0x0, 0xe8, + 0xf5, 0x0, 0x0, 0xe8, 0xf8, 0x44, 0x5a, 0xf2, + 0xff, 0xff, 0xfc, 0x50, + + /* U+0043 "C" */ + 0x0, 0x19, 0xef, 0xd6, 0x0, 0x1, 0xec, 0x54, + 0x7f, 0x90, 0xa, 0xd0, 0x0, 0x5, 0xf2, 0xf, + 0x60, 0x0, 0x0, 0x51, 0x3f, 0x20, 0x0, 0x0, + 0x0, 0x4f, 0x10, 0x0, 0x0, 0x0, 0x3f, 0x20, + 0x0, 0x0, 0x0, 0xf, 0x50, 0x0, 0x0, 0xc4, + 0xa, 0xd0, 0x0, 0x5, 0xf2, 0x1, 0xec, 0x54, + 0x8f, 0x80, 0x0, 0x1a, 0xef, 0xd6, 0x0, + + /* U+0044 "D" */ + 0xef, 0xff, 0xfc, 0x40, 0xe, 0x94, 0x45, 0xaf, + 0x40, 0xe6, 0x0, 0x0, 0xad, 0xe, 0x60, 0x0, + 0x3, 0xf2, 0xe6, 0x0, 0x0, 0xf, 0x5e, 0x60, + 0x0, 0x0, 0xf5, 0xe6, 0x0, 0x0, 0x1f, 0x4e, + 0x60, 0x0, 0x4, 0xf2, 0xe6, 0x0, 0x0, 0xbc, + 0xe, 0x94, 0x45, 0xbf, 0x30, 0xef, 0xff, 0xeb, + 0x30, 0x0, + + /* U+0045 "E" */ + 0xef, 0xff, 0xff, 0xf5, 0xe9, 0x44, 0x44, 0x41, + 0xe7, 0x0, 0x0, 0x0, 0xe7, 0x0, 0x0, 0x0, + 0xe7, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xf0, + 0xe8, 0x33, 0x33, 0x30, 0xe7, 0x0, 0x0, 0x0, + 0xe7, 0x0, 0x0, 0x0, 0xe9, 0x44, 0x44, 0x42, + 0xef, 0xff, 0xff, 0xf9, + + /* U+0046 "F" */ + 0xef, 0xff, 0xff, 0xee, 0x94, 0x44, 0x43, 0xe7, + 0x0, 0x0, 0xe, 0x70, 0x0, 0x0, 0xe7, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xf2, 0xe9, 0x33, 0x33, + 0xe, 0x70, 0x0, 0x0, 0xe7, 0x0, 0x0, 0xe, + 0x70, 0x0, 0x0, 0xe7, 0x0, 0x0, 0x0, + + /* U+0047 "G" */ + 0x0, 0x8, 0xdf, 0xeb, 0x30, 0x0, 0xdd, 0x63, + 0x5b, 0xf2, 0x9, 0xe1, 0x0, 0x0, 0xba, 0xf, + 0x70, 0x0, 0x0, 0x10, 0x3f, 0x30, 0x0, 0x0, + 0x0, 0x4f, 0x10, 0x4, 0xff, 0xff, 0x3f, 0x20, + 0x0, 0x33, 0x7f, 0xf, 0x60, 0x0, 0x0, 0x4f, + 0x9, 0xe1, 0x0, 0x0, 0x7f, 0x0, 0xce, 0x85, + 0x6c, 0xfa, 0x0, 0x7, 0xdf, 0xfb, 0x40, + + /* U+0048 "H" */ + 0xe7, 0x0, 0x0, 0x5f, 0xe7, 0x0, 0x0, 0x5f, + 0xe7, 0x0, 0x0, 0x5f, 0xe7, 0x0, 0x0, 0x5f, + 0xe7, 0x0, 0x0, 0x5f, 0xef, 0xff, 0xff, 0xff, + 0xe9, 0x33, 0x33, 0x7f, 0xe7, 0x0, 0x0, 0x5f, + 0xe7, 0x0, 0x0, 0x5f, 0xe7, 0x0, 0x0, 0x5f, + 0xe7, 0x0, 0x0, 0x5f, + + /* U+0049 "I" */ + 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, + 0xb9, 0xb9, 0xb9, + + /* U+004A "J" */ + 0x0, 0x0, 0x6e, 0x0, 0x0, 0x6e, 0x0, 0x0, + 0x6e, 0x0, 0x0, 0x6e, 0x0, 0x0, 0x6e, 0x0, + 0x0, 0x6e, 0x0, 0x0, 0x6e, 0x23, 0x0, 0x6e, + 0x8b, 0x0, 0x8d, 0x4f, 0x75, 0xe8, 0x7, 0xee, + 0x90, + + /* U+004B "K" */ + 0xf5, 0x0, 0x2, 0xfa, 0xf, 0x50, 0x2, 0xeb, + 0x0, 0xf5, 0x1, 0xdb, 0x0, 0xf, 0x50, 0xcc, + 0x0, 0x0, 0xf6, 0xbf, 0x20, 0x0, 0xf, 0xed, + 0xe9, 0x0, 0x0, 0xfe, 0x15, 0xf4, 0x0, 0xf, + 0x60, 0xa, 0xe1, 0x0, 0xf5, 0x0, 0x1f, 0xa0, + 0xf, 0x50, 0x0, 0x6f, 0x40, 0xf5, 0x0, 0x0, + 0xce, 0x10, + + /* U+004C "L" */ + 0xf6, 0x0, 0x0, 0xf, 0x60, 0x0, 0x0, 0xf6, + 0x0, 0x0, 0xf, 0x60, 0x0, 0x0, 0xf6, 0x0, + 0x0, 0xf, 0x60, 0x0, 0x0, 0xf6, 0x0, 0x0, + 0xf, 0x60, 0x0, 0x0, 0xf6, 0x0, 0x0, 0xf, + 0x84, 0x44, 0x41, 0xff, 0xff, 0xff, 0x50, + + /* U+004D "M" */ + 0xff, 0x30, 0x0, 0x5, 0xf9, 0xff, 0x80, 0x0, + 0xa, 0xf9, 0xfb, 0xc0, 0x0, 0xe, 0xc9, 0xf6, + 0xf1, 0x0, 0x4c, 0xa9, 0xf5, 0xc6, 0x0, 0x97, + 0xa9, 0xf5, 0x7b, 0x0, 0xe2, 0xa9, 0xf5, 0x2f, + 0x3, 0xd0, 0xa9, 0xf5, 0xd, 0x58, 0x80, 0xa9, + 0xf5, 0x8, 0xad, 0x30, 0xa9, 0xf5, 0x3, 0xfe, + 0x0, 0xa9, 0xf5, 0x0, 0xe9, 0x0, 0xa9, + + /* U+004E "N" */ + 0xec, 0x0, 0x0, 0x4f, 0xef, 0x60, 0x0, 0x4f, + 0xee, 0xe1, 0x0, 0x4f, 0xe6, 0xe9, 0x0, 0x4f, + 0xe6, 0x5f, 0x30, 0x4f, 0xe6, 0xb, 0xc0, 0x4f, + 0xe6, 0x2, 0xf6, 0x4f, 0xe6, 0x0, 0x7f, 0x5f, + 0xe6, 0x0, 0xd, 0xdf, 0xe6, 0x0, 0x4, 0xff, + 0xe6, 0x0, 0x0, 0xaf, + + /* U+004F "O" */ + 0x0, 0x19, 0xef, 0xd8, 0x0, 0x0, 0x1d, 0xd6, + 0x46, 0xec, 0x0, 0xa, 0xd0, 0x0, 0x1, 0xf8, + 0x1, 0xf5, 0x0, 0x0, 0x8, 0xe0, 0x4f, 0x10, + 0x0, 0x0, 0x4f, 0x25, 0xf0, 0x0, 0x0, 0x2, + 0xf3, 0x4f, 0x20, 0x0, 0x0, 0x4f, 0x20, 0xf6, + 0x0, 0x0, 0x7, 0xf0, 0xa, 0xd0, 0x0, 0x1, + 0xe8, 0x0, 0x1d, 0xd5, 0x36, 0xec, 0x0, 0x0, + 0x18, 0xdf, 0xd8, 0x0, 0x0, + + /* U+0050 "P" */ + 0xef, 0xff, 0xfd, 0x60, 0xe9, 0x44, 0x48, 0xf5, + 0xe6, 0x0, 0x0, 0xca, 0xe6, 0x0, 0x0, 0xba, + 0xe6, 0x0, 0x16, 0xf6, 0xef, 0xff, 0xff, 0x90, + 0xe8, 0x33, 0x31, 0x0, 0xe6, 0x0, 0x0, 0x0, + 0xe6, 0x0, 0x0, 0x0, 0xe6, 0x0, 0x0, 0x0, + 0xe6, 0x0, 0x0, 0x0, + + /* U+0051 "Q" */ + 0x0, 0x19, 0xef, 0xd7, 0x0, 0x0, 0x1d, 0xd6, + 0x46, 0xdc, 0x0, 0xa, 0xd0, 0x0, 0x1, 0xe8, + 0x1, 0xf5, 0x0, 0x0, 0x7, 0xe0, 0x4f, 0x10, + 0x0, 0x0, 0x4f, 0x25, 0xf0, 0x0, 0x0, 0x2, + 0xf3, 0x4f, 0x20, 0x0, 0x0, 0x3f, 0x21, 0xf6, + 0x0, 0x0, 0x7, 0xe0, 0xa, 0xd0, 0x5, 0xd5, + 0xe8, 0x0, 0x1d, 0xd5, 0x3b, 0xfe, 0x0, 0x0, + 0x19, 0xef, 0xd8, 0xcd, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x61, + + /* U+0052 "R" */ + 0xef, 0xff, 0xfe, 0xb1, 0xe, 0x83, 0x33, 0x5e, + 0xb0, 0xe7, 0x0, 0x0, 0x5f, 0x1e, 0x70, 0x0, + 0x5, 0xf1, 0xe7, 0x0, 0x3, 0xdc, 0xe, 0xff, + 0xff, 0xfb, 0x10, 0xe9, 0x34, 0xbc, 0x10, 0xe, + 0x70, 0x0, 0xdc, 0x0, 0xe7, 0x0, 0x3, 0xf7, + 0xe, 0x70, 0x0, 0x9, 0xf1, 0xe7, 0x0, 0x0, + 0x1e, 0xa0, + + /* U+0053 "S" */ + 0x0, 0x7d, 0xfd, 0x80, 0x0, 0x8e, 0x74, 0x6d, + 0xb0, 0xe, 0x60, 0x0, 0x3f, 0x20, 0xe8, 0x0, + 0x0, 0x40, 0x6, 0xfc, 0x73, 0x0, 0x0, 0x4, + 0xae, 0xfe, 0x60, 0x0, 0x0, 0x3, 0xaf, 0x43, + 0xa0, 0x0, 0x0, 0xc8, 0x2f, 0x50, 0x0, 0xd, + 0x80, 0xaf, 0x85, 0x5b, 0xf2, 0x0, 0x7d, 0xfe, + 0xb2, 0x0, + + /* U+0054 "T" */ + 0xbf, 0xff, 0xff, 0xff, 0x42, 0x44, 0x8f, 0x44, + 0x41, 0x0, 0x6, 0xe0, 0x0, 0x0, 0x0, 0x6e, + 0x0, 0x0, 0x0, 0x6, 0xe0, 0x0, 0x0, 0x0, + 0x6e, 0x0, 0x0, 0x0, 0x6, 0xe0, 0x0, 0x0, + 0x0, 0x6e, 0x0, 0x0, 0x0, 0x6, 0xe0, 0x0, + 0x0, 0x0, 0x6e, 0x0, 0x0, 0x0, 0x6, 0xe0, + 0x0, 0x0, + + /* U+0055 "U" */ + 0xe7, 0x0, 0x0, 0x5f, 0xe7, 0x0, 0x0, 0x5f, + 0xe7, 0x0, 0x0, 0x5f, 0xe7, 0x0, 0x0, 0x5f, + 0xe7, 0x0, 0x0, 0x5f, 0xe7, 0x0, 0x0, 0x5f, + 0xe7, 0x0, 0x0, 0x5f, 0xc8, 0x0, 0x0, 0x6e, + 0x9c, 0x0, 0x0, 0xbb, 0x3f, 0xb5, 0x6a, 0xf4, + 0x4, 0xcf, 0xfc, 0x40, + + /* U+0056 "V" */ + 0xca, 0x0, 0x0, 0x4, 0xf1, 0x6f, 0x0, 0x0, + 0xa, 0xb0, 0x1f, 0x50, 0x0, 0xf, 0x50, 0xb, + 0xa0, 0x0, 0x4f, 0x0, 0x5, 0xf0, 0x0, 0xaa, + 0x0, 0x0, 0xf4, 0x0, 0xf4, 0x0, 0x0, 0xa9, + 0x5, 0xe0, 0x0, 0x0, 0x4e, 0xa, 0x80, 0x0, + 0x0, 0xe, 0x4f, 0x30, 0x0, 0x0, 0x9, 0xdd, + 0x0, 0x0, 0x0, 0x3, 0xf7, 0x0, 0x0, + + /* U+0057 "W" */ + 0xb9, 0x0, 0x5, 0xf8, 0x0, 0x6, 0xe0, 0x8d, + 0x0, 0x9, 0xec, 0x0, 0xa, 0xa0, 0x4f, 0x0, + 0xd, 0x7f, 0x0, 0xd, 0x60, 0xf, 0x30, 0x1f, + 0x1e, 0x40, 0x1f, 0x20, 0xc, 0x70, 0x5c, 0xa, + 0x90, 0x4e, 0x0, 0x8, 0xa0, 0x98, 0x6, 0xd0, + 0x8a, 0x0, 0x4, 0xe0, 0xd4, 0x2, 0xf0, 0xb6, + 0x0, 0x0, 0xf3, 0xf0, 0x0, 0xe4, 0xf2, 0x0, + 0x0, 0xc9, 0xc0, 0x0, 0xaa, 0xe0, 0x0, 0x0, + 0x9f, 0x80, 0x0, 0x6f, 0xa0, 0x0, 0x0, 0x5f, + 0x40, 0x0, 0x2f, 0x60, 0x0, + + /* U+0058 "X" */ + 0x2f, 0x60, 0x0, 0xc, 0xa0, 0x8, 0xf1, 0x0, + 0x8e, 0x0, 0x0, 0xdb, 0x3, 0xf4, 0x0, 0x0, + 0x3f, 0x5d, 0x90, 0x0, 0x0, 0x9, 0xfd, 0x0, + 0x0, 0x0, 0x4, 0xfa, 0x0, 0x0, 0x0, 0xd, + 0xcf, 0x40, 0x0, 0x0, 0x9e, 0xa, 0xe1, 0x0, + 0x4, 0xf4, 0x1, 0xe9, 0x0, 0xd, 0xa0, 0x0, + 0x5f, 0x40, 0x9e, 0x10, 0x0, 0xb, 0xd0, + + /* U+0059 "Y" */ + 0xae, 0x0, 0x0, 0x9, 0xe0, 0x1f, 0x80, 0x0, + 0x3f, 0x40, 0x6, 0xf2, 0x0, 0xca, 0x0, 0x0, + 0xcb, 0x6, 0xe1, 0x0, 0x0, 0x3f, 0x5e, 0x60, + 0x0, 0x0, 0x9, 0xfc, 0x0, 0x0, 0x0, 0x2, + 0xf4, 0x0, 0x0, 0x0, 0x1, 0xf3, 0x0, 0x0, + 0x0, 0x1, 0xf3, 0x0, 0x0, 0x0, 0x1, 0xf3, + 0x0, 0x0, 0x0, 0x1, 0xf3, 0x0, 0x0, + + /* U+005A "Z" */ + 0x2f, 0xff, 0xff, 0xff, 0x0, 0x44, 0x44, 0x4e, + 0xd0, 0x0, 0x0, 0x8, 0xf2, 0x0, 0x0, 0x4, + 0xf6, 0x0, 0x0, 0x1, 0xea, 0x0, 0x0, 0x0, + 0xbd, 0x0, 0x0, 0x0, 0x7f, 0x30, 0x0, 0x0, + 0x3f, 0x70, 0x0, 0x0, 0xd, 0xb0, 0x0, 0x0, + 0x9, 0xf5, 0x44, 0x44, 0x40, 0xcf, 0xff, 0xff, + 0xff, 0x20, + + /* U+005B "[" */ + 0x1f, 0xfa, 0x1f, 0x30, 0x1f, 0x20, 0x1f, 0x20, + 0x1f, 0x20, 0x1f, 0x20, 0x1f, 0x20, 0x1f, 0x20, + 0x1f, 0x20, 0x1f, 0x20, 0x1f, 0x20, 0x1f, 0x20, + 0x1f, 0x30, 0x1f, 0xfa, + + /* U+005C "\\" */ + 0xd1, 0x0, 0x96, 0x0, 0x5a, 0x0, 0x1e, 0x0, + 0xd, 0x20, 0x8, 0x60, 0x4, 0xb0, 0x0, 0xe0, + 0x0, 0xc3, 0x0, 0x77, 0x0, 0x3c, + + /* U+005D "]" */ + 0xcf, 0xf1, 0x5f, 0x4, 0xf0, 0x4f, 0x4, 0xf0, + 0x4f, 0x4, 0xf0, 0x4f, 0x4, 0xf0, 0x4f, 0x4, + 0xf0, 0x4f, 0x15, 0xfc, 0xff, + + /* U+005E "^" */ + 0x0, 0x6f, 0x0, 0x0, 0xd, 0xe6, 0x0, 0x3, + 0xe5, 0xc0, 0x0, 0xa8, 0xf, 0x30, 0x1f, 0x30, + 0x99, 0x6, 0xd0, 0x3, 0xf0, + + /* U+005F "_" */ + 0x1f, 0xff, 0xff, 0xff, 0xd0, + + /* U+0060 "`" */ + 0x1, 0x0, 0x1e, 0x80, 0x3, 0xe0, + + /* U+0061 "a" */ + 0x3, 0xbf, 0xfb, 0x20, 0xe, 0x82, 0x3c, 0xa0, + 0x17, 0x0, 0x7, 0xc0, 0x0, 0x59, 0xcf, 0xd0, + 0x1e, 0xc7, 0x47, 0xd0, 0x6e, 0x0, 0x9, 0xd0, + 0x5f, 0x41, 0x5f, 0xd0, 0x9, 0xee, 0xb6, 0xf1, + + /* U+0062 "b" */ + 0x1f, 0x20, 0x0, 0x0, 0x1f, 0x20, 0x0, 0x0, + 0x1f, 0x20, 0x0, 0x0, 0x1f, 0x7e, 0xfa, 0x0, + 0x1f, 0xe4, 0x3d, 0x90, 0x1f, 0x50, 0x4, 0xf0, + 0x1f, 0x20, 0x1, 0xf2, 0x1f, 0x10, 0x1, 0xf2, + 0x1f, 0x30, 0x4, 0xf0, 0x1f, 0xc0, 0x1c, 0x80, + 0x1f, 0x7d, 0xe9, 0x0, + + /* U+0063 "c" */ + 0x1, 0xbf, 0xe8, 0x0, 0xcb, 0x23, 0xe6, 0x3f, + 0x10, 0x5, 0x56, 0xd0, 0x0, 0x0, 0x6d, 0x0, + 0x0, 0x3, 0xf1, 0x0, 0x7a, 0xc, 0xa2, 0x3e, + 0x60, 0x2b, 0xfe, 0x70, + + /* U+0064 "d" */ + 0x0, 0x0, 0x6, 0xc0, 0x0, 0x0, 0x6c, 0x0, + 0x0, 0x6, 0xc0, 0x2c, 0xfc, 0x9c, 0xd, 0xa2, + 0x5f, 0xc4, 0xf0, 0x0, 0x9c, 0x7d, 0x0, 0x6, + 0xc6, 0xd0, 0x0, 0x5c, 0x4f, 0x10, 0x8, 0xc0, + 0xca, 0x25, 0xfc, 0x2, 0xbf, 0xd8, 0xc0, + + /* U+0065 "e" */ + 0x1, 0xaf, 0xe9, 0x0, 0xb, 0xb2, 0x3c, 0x90, + 0x3f, 0x0, 0x3, 0xf0, 0x6f, 0xff, 0xff, 0xf2, + 0x6e, 0x22, 0x22, 0x20, 0x3f, 0x20, 0x2, 0xa0, + 0xc, 0xc3, 0x2c, 0xb0, 0x1, 0xaf, 0xea, 0x10, + + /* U+0066 "f" */ + 0x4, 0xef, 0x40, 0xbb, 0x40, 0xc, 0x60, 0xe, + 0xff, 0xd0, 0xc, 0x70, 0x0, 0xc6, 0x0, 0xc, + 0x60, 0x0, 0xc6, 0x0, 0xc, 0x60, 0x0, 0xc6, + 0x0, 0xc, 0x60, 0x0, + + /* U+0067 "g" */ + 0x2, 0xcf, 0xd7, 0xe0, 0xda, 0x25, 0xfe, 0x4f, + 0x0, 0x8, 0xe7, 0xc0, 0x0, 0x5e, 0x7c, 0x0, + 0x5, 0xe4, 0xf0, 0x0, 0x8e, 0xd, 0xa2, 0x5f, + 0xd0, 0x2c, 0xfc, 0x9d, 0x14, 0x0, 0x7, 0xb1, + 0xf6, 0x14, 0xe6, 0x5, 0xdf, 0xe7, 0x0, + + /* U+0068 "h" */ + 0x1f, 0x20, 0x0, 0x1, 0xf2, 0x0, 0x0, 0x1f, + 0x20, 0x0, 0x1, 0xf7, 0xdf, 0xb1, 0x1f, 0xd4, + 0x3d, 0x91, 0xf5, 0x0, 0x7c, 0x1f, 0x20, 0x6, + 0xd1, 0xf2, 0x0, 0x6d, 0x1f, 0x20, 0x6, 0xd1, + 0xf2, 0x0, 0x6d, 0x1f, 0x20, 0x6, 0xd0, + + /* U+0069 "i" */ + 0x1f, 0x20, 0x81, 0x0, 0x1, 0xf2, 0x1f, 0x21, + 0xf2, 0x1f, 0x21, 0xf2, 0x1f, 0x21, 0xf2, 0x1f, + 0x20, + + /* U+006A "j" */ + 0x1, 0xf2, 0x0, 0x81, 0x0, 0x0, 0x1, 0xf2, + 0x1, 0xf2, 0x1, 0xf2, 0x1, 0xf2, 0x1, 0xf2, + 0x1, 0xf2, 0x1, 0xf2, 0x1, 0xf2, 0x1, 0xf2, + 0x15, 0xf0, 0x7f, 0x80, + + /* U+006B "k" */ + 0x1f, 0x20, 0x0, 0x1, 0xf2, 0x0, 0x0, 0x1f, + 0x20, 0x0, 0x1, 0xf2, 0x6, 0xf3, 0x1f, 0x24, + 0xf4, 0x1, 0xf5, 0xf5, 0x0, 0x1f, 0xff, 0x30, + 0x1, 0xf7, 0x9c, 0x0, 0x1f, 0x21, 0xf6, 0x1, + 0xf2, 0x7, 0xf1, 0x1f, 0x20, 0xd, 0xa0, + + /* U+006C "l" */ + 0x1f, 0x21, 0xf2, 0x1f, 0x21, 0xf2, 0x1f, 0x21, + 0xf2, 0x1f, 0x21, 0xf2, 0x1f, 0x21, 0xf2, 0x1f, + 0x20, + + /* U+006D "m" */ + 0x1f, 0x6e, 0xfa, 0x2c, 0xfc, 0x11, 0xfb, 0x12, + 0xfe, 0x30, 0xc9, 0x1f, 0x40, 0xc, 0x90, 0x8, + 0xb1, 0xf2, 0x0, 0xc7, 0x0, 0x7c, 0x1f, 0x20, + 0xc, 0x70, 0x7, 0xc1, 0xf2, 0x0, 0xc7, 0x0, + 0x7c, 0x1f, 0x20, 0xc, 0x70, 0x7, 0xc1, 0xf2, + 0x0, 0xc7, 0x0, 0x7c, + + /* U+006E "n" */ + 0xf, 0x6d, 0xfb, 0x10, 0xfc, 0x11, 0xc9, 0xf, + 0x50, 0x6, 0xc0, 0xf3, 0x0, 0x6d, 0xf, 0x30, + 0x6, 0xd0, 0xf3, 0x0, 0x6d, 0xf, 0x30, 0x6, + 0xd0, 0xf3, 0x0, 0x6d, + + /* U+006F "o" */ + 0x1, 0xae, 0xe9, 0x0, 0xd, 0xb2, 0x3d, 0x90, + 0x5f, 0x10, 0x4, 0xf1, 0x7c, 0x0, 0x0, 0xf3, + 0x7c, 0x0, 0x0, 0xf4, 0x5f, 0x10, 0x4, 0xf1, + 0xd, 0xb2, 0x3d, 0xa0, 0x1, 0xae, 0xe9, 0x0, + + /* U+0070 "p" */ + 0xf, 0x7d, 0xea, 0x0, 0xf, 0xd1, 0xb, 0x90, + 0xf, 0x40, 0x3, 0xf0, 0xf, 0x10, 0x0, 0xf3, + 0xf, 0x10, 0x1, 0xf2, 0xf, 0x50, 0x4, 0xf0, + 0xf, 0xd3, 0x3d, 0x80, 0xf, 0x8d, 0xf9, 0x0, + 0xf, 0x30, 0x0, 0x0, 0xf, 0x30, 0x0, 0x0, + 0xf, 0x30, 0x0, 0x0, + + /* U+0071 "q" */ + 0x2, 0xcf, 0xc7, 0xd0, 0xda, 0x15, 0xfd, 0x4f, + 0x0, 0x9, 0xd6, 0xd0, 0x0, 0x5d, 0x6d, 0x0, + 0x5, 0xd3, 0xf1, 0x0, 0x8d, 0xc, 0xb2, 0x5f, + 0xd0, 0x1b, 0xfd, 0x9d, 0x0, 0x0, 0x6, 0xd0, + 0x0, 0x0, 0x6d, 0x0, 0x0, 0x6, 0xd0, + + /* U+0072 "r" */ + 0x1f, 0x7f, 0x91, 0xfc, 0x43, 0x1f, 0x40, 0x1, + 0xf2, 0x0, 0x1f, 0x20, 0x1, 0xf2, 0x0, 0x1f, + 0x20, 0x1, 0xf2, 0x0, + + /* U+0073 "s" */ + 0x6, 0xef, 0xc4, 0x3, 0xf4, 0x28, 0xf0, 0x4e, + 0x20, 0x4, 0x0, 0xbf, 0xc8, 0x20, 0x0, 0x48, + 0xdf, 0x23, 0x70, 0x0, 0xe6, 0x3f, 0x51, 0x5f, + 0x30, 0x6d, 0xfd, 0x50, + + /* U+0074 "t" */ + 0x3, 0x30, 0xd, 0x50, 0xe, 0x50, 0xcf, 0xf9, + 0xe, 0x60, 0xe, 0x50, 0xe, 0x50, 0xe, 0x50, + 0xd, 0x50, 0xd, 0x92, 0x6, 0xfa, + + /* U+0075 "u" */ + 0x1f, 0x20, 0x6, 0xd1, 0xf2, 0x0, 0x6d, 0x1f, + 0x20, 0x6, 0xd1, 0xf2, 0x0, 0x6d, 0x1f, 0x20, + 0x7, 0xd0, 0xf3, 0x0, 0x9d, 0xd, 0xa2, 0x6e, + 0xd0, 0x3d, 0xfb, 0x6d, + + /* U+0076 "v" */ + 0xaa, 0x0, 0x9, 0xa5, 0xf0, 0x0, 0xe5, 0xf, + 0x40, 0x4f, 0x0, 0x99, 0x9, 0xa0, 0x4, 0xe0, + 0xe4, 0x0, 0xe, 0x7e, 0x0, 0x0, 0x9f, 0x90, + 0x0, 0x3, 0xf4, 0x0, + + /* U+0077 "w" */ + 0xc7, 0x0, 0xad, 0x0, 0x4e, 0x8, 0xb0, 0xe, + 0xf1, 0x9, 0x90, 0x3f, 0x2, 0xed, 0x40, 0xd5, + 0x0, 0xf3, 0x6a, 0x98, 0x1f, 0x0, 0xa, 0x7a, + 0x65, 0xc5, 0xc0, 0x0, 0x6b, 0xe2, 0x1f, 0xa7, + 0x0, 0x1, 0xfe, 0x0, 0xef, 0x30, 0x0, 0xd, + 0xb0, 0xa, 0xe0, 0x0, + + /* U+0078 "x" */ + 0x6f, 0x20, 0x2f, 0x50, 0xbb, 0xb, 0xb0, 0x2, + 0xfa, 0xe1, 0x0, 0x7, 0xf6, 0x0, 0x0, 0xaf, + 0xa0, 0x0, 0x4f, 0x4f, 0x40, 0xe, 0x70, 0x8e, + 0x9, 0xd0, 0x0, 0xd9, + + /* U+0079 "y" */ + 0x9b, 0x0, 0x8, 0xb4, 0xf1, 0x0, 0xd5, 0xe, + 0x60, 0x3f, 0x0, 0x8b, 0x8, 0xa0, 0x3, 0xf1, + 0xe4, 0x0, 0xd, 0x8e, 0x0, 0x0, 0x7f, 0x90, + 0x0, 0x2, 0xf4, 0x0, 0x0, 0x4e, 0x0, 0x1, + 0x5c, 0x70, 0x0, 0x2f, 0xb0, 0x0, 0x0, + + /* U+007A "z" */ + 0x7f, 0xff, 0xff, 0x70, 0x11, 0x18, 0xe1, 0x0, + 0x4, 0xf4, 0x0, 0x1, 0xe7, 0x0, 0x0, 0xcb, + 0x0, 0x0, 0x9d, 0x0, 0x0, 0x6f, 0x42, 0x22, + 0x1b, 0xff, 0xff, 0xfb, + + /* U+007B "{" */ + 0x0, 0x8f, 0x50, 0x1f, 0x50, 0x2, 0xf0, 0x0, + 0x3f, 0x0, 0x4, 0xe0, 0x0, 0xaa, 0x0, 0x9d, + 0x10, 0x2, 0xc7, 0x0, 0x4, 0xd0, 0x0, 0x3f, + 0x0, 0x2, 0xf0, 0x0, 0x2f, 0x0, 0x0, 0xf5, + 0x0, 0x7, 0xf5, + + /* U+007C "|" */ + 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, + 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, + + /* U+007D "}" */ + 0xae, 0x30, 0x1, 0x9b, 0x0, 0x5, 0xd0, 0x0, + 0x4d, 0x0, 0x3, 0xe0, 0x0, 0xe, 0x50, 0x0, + 0x4f, 0x40, 0xc, 0x81, 0x2, 0xf0, 0x0, 0x4e, + 0x0, 0x4, 0xd0, 0x0, 0x5d, 0x0, 0x19, 0xb0, + 0xa, 0xd3, 0x0, + + /* U+007E "~" */ + 0x0, 0x0, 0x0, 0x0, 0x2d, 0xfe, 0x82, 0x58, + 0x69, 0x59, 0xff, 0xf6, 0x0, 0x0, 0x3, 0x10, + + /* U+00A0 " " */ + + /* U+00A3 "£" */ + 0x0, 0x8e, 0xfa, 0x10, 0x8, 0xe4, 0x3c, 0xb0, + 0xd, 0x60, 0x3, 0xe0, 0xe, 0x60, 0x0, 0x0, + 0xc, 0x90, 0x0, 0x0, 0xaf, 0xff, 0xd0, 0x0, + 0x16, 0xf2, 0x20, 0x0, 0x4, 0xe0, 0x0, 0x0, + 0x9, 0x70, 0x0, 0x0, 0x6f, 0xdd, 0x95, 0x82, + 0x77, 0x34, 0xaf, 0xd2, 0x0, 0x0, 0x0, 0x0, + + /* U+00A4 "¤" */ + 0x3, 0x0, 0x0, 0x30, 0x3f, 0xaf, 0xea, 0xe1, + 0xa, 0xd4, 0x6f, 0x70, 0xe, 0x30, 0x7, 0xb0, + 0xf, 0x30, 0x6, 0xb0, 0xa, 0xb1, 0x3e, 0x70, + 0x2f, 0xdf, 0xfd, 0xd1, 0x6, 0x2, 0x10, 0x60, + + /* U+00A5 "¥" */ + 0xba, 0x0, 0x0, 0xe7, 0x2f, 0x30, 0x7, 0xe0, + 0x9, 0xb0, 0xe, 0x60, 0x1, 0xf4, 0x8d, 0x0, + 0x0, 0x8c, 0xf4, 0x0, 0x8f, 0xff, 0xff, 0xf5, + 0x12, 0x2c, 0x92, 0x20, 0x8e, 0xef, 0xfe, 0xe4, + 0x1, 0x1b, 0x91, 0x10, 0x0, 0xb, 0x80, 0x0, + 0x0, 0xb, 0x80, 0x0, + + /* U+00A6 "¦" */ + 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0x94, 0x0, 0x0, + 0x94, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, + + /* U+00A7 "§" */ + 0x0, 0xaf, 0xe7, 0x0, 0x8, 0xc2, 0x4f, 0x40, + 0xb, 0x80, 0x7, 0x40, 0x5, 0xf5, 0x0, 0x0, + 0x8, 0xdf, 0xa1, 0x0, 0x4d, 0x3, 0xde, 0x20, + 0x5d, 0x0, 0xb, 0xe0, 0x1e, 0x90, 0x1, 0xf2, + 0x2, 0xdd, 0x34, 0xd0, 0x0, 0x8, 0xfd, 0x10, + 0x0, 0x0, 0x4f, 0x60, 0xa, 0x40, 0x9, 0xa0, + 0xa, 0xd3, 0x3d, 0x70, 0x1, 0xae, 0xe9, 0x0, + + /* U+00A8 "¨" */ + 0x45, 0x8, 0x29, 0xb0, 0xf4, + + /* U+00A9 "©" */ + 0x0, 0x29, 0xde, 0xb5, 0x0, 0x0, 0x5d, 0x50, + 0x3, 0xb9, 0x0, 0x2d, 0x13, 0xcd, 0x80, 0xa6, + 0x9, 0x41, 0xe2, 0xa, 0x50, 0xe0, 0xd0, 0x68, + 0x0, 0x0, 0xa, 0x3d, 0x8, 0x60, 0x0, 0x0, + 0x84, 0xd0, 0x68, 0x0, 0x23, 0xa, 0x3a, 0x41, + 0xd2, 0xb, 0x50, 0xd0, 0x2d, 0x14, 0xcd, 0x70, + 0xa6, 0x0, 0x5d, 0x50, 0x3, 0xb9, 0x0, 0x0, + 0x2a, 0xee, 0xc5, 0x0, 0x0, + + /* U+00AA "ª" */ + 0x1c, 0xb9, 0xe0, 0x97, 0x9, 0xa0, 0xb4, 0x6, + 0x80, 0x97, 0xa, 0xa0, 0x1c, 0xc9, 0xe0, + + /* U+00AB "«" */ + 0x0, 0x1a, 0x5, 0x60, 0xa, 0x71, 0xe2, 0x5, + 0xe0, 0xa9, 0x0, 0xe8, 0x3f, 0x20, 0x8, 0xc0, + 0xc7, 0x0, 0xd, 0x53, 0xe1, 0x0, 0x3d, 0x8, + 0x80, + + /* U+00AC "¬" */ + 0x3f, 0xff, 0xff, 0xf6, 0x4, 0x44, 0x44, 0xd6, + 0x0, 0x0, 0x0, 0xc6, 0x0, 0x0, 0x0, 0xc6, + 0x0, 0x0, 0x0, 0x31, + + /* U+00AD "­" */ + 0x1, 0x11, 0x9, 0xff, 0xf3, 0x24, 0x44, 0x0, + + /* U+00AE "®" */ + 0x0, 0x29, 0xde, 0xb5, 0x0, 0x0, 0x5d, 0x50, + 0x3, 0xb9, 0x0, 0x2d, 0x2e, 0xdd, 0x70, 0xa6, + 0x9, 0x41, 0xc0, 0xe, 0x10, 0xe0, 0xd0, 0x1c, + 0x0, 0xd1, 0xa, 0x3d, 0x1, 0xfd, 0xe5, 0x0, + 0x84, 0xd0, 0x1c, 0xa, 0x50, 0xa, 0x3a, 0x41, + 0xc0, 0x1e, 0x10, 0xd0, 0x2d, 0x25, 0x0, 0x43, + 0xa6, 0x0, 0x5d, 0x50, 0x3, 0xb9, 0x0, 0x0, + 0x2a, 0xee, 0xc5, 0x0, 0x0, + + /* U+00B0 "°" */ + 0x5, 0xcb, 0x10, 0xc0, 0x49, 0xc, 0x4, 0x90, + 0x5c, 0xb1, + + /* U+00B1 "±" */ + 0x0, 0x8, 0xa0, 0x0, 0x0, 0x8, 0xa0, 0x0, + 0x0, 0x8, 0xa0, 0x0, 0x3f, 0xff, 0xff, 0xf6, + 0x3, 0x39, 0xb3, 0x31, 0x0, 0x8, 0xa0, 0x0, + 0x0, 0x8, 0xa0, 0x0, 0x3, 0x34, 0x53, 0x31, + 0x3f, 0xff, 0xff, 0xf6, + + /* U+00B2 "²" */ + 0x3c, 0xdc, 0x14, 0x40, 0xc5, 0x0, 0x7c, 0x0, + 0xb9, 0x0, 0x9f, 0xdd, 0x50, + + /* U+00B3 "³" */ + 0x3d, 0xcb, 0x3, 0x30, 0xf1, 0x0, 0xdb, 0x4, + 0x20, 0xc5, 0x4d, 0xdb, 0x10, + + /* U+00B5 "µ" */ + 0xf, 0x20, 0x6, 0xd0, 0xf2, 0x0, 0x6d, 0xf, + 0x20, 0x6, 0xd0, 0xf2, 0x0, 0x6d, 0xf, 0x30, + 0x6, 0xd0, 0xf4, 0x0, 0x8d, 0xf, 0xc1, 0x3e, + 0xd0, 0xf9, 0xed, 0x9d, 0xf, 0x20, 0x0, 0x0, + 0xf2, 0x0, 0x0, 0xf, 0x20, 0x0, 0x0, + + /* U+00B6 "¶" */ + 0x0, 0x9e, 0xff, 0xff, 0x80, 0x9f, 0xfe, 0x4b, + 0xa2, 0xe, 0xff, 0xd0, 0x98, 0x0, 0xff, 0xfd, + 0x9, 0x80, 0xb, 0xff, 0xd0, 0x98, 0x0, 0x2d, + 0xfd, 0x9, 0x80, 0x0, 0x5, 0xd0, 0x98, 0x0, + 0x0, 0x4d, 0x9, 0x80, 0x0, 0x4, 0xd0, 0x98, + 0x0, 0x0, 0x4d, 0x9, 0x80, 0x0, 0x4, 0xd0, + 0x98, 0x0, 0x0, 0x4d, 0x9, 0x80, 0x0, 0x4, + 0xd0, 0x98, 0x0, 0x0, 0x4d, 0x9, 0x80, + + /* U+00B7 "·" */ + 0x65, 0xba, + + /* U+00BB "»" */ + 0x9, 0x21, 0xa0, 0x0, 0x5c, 0xb, 0x70, 0x0, + 0xc6, 0x2f, 0x20, 0x5, 0xf0, 0xba, 0x0, 0xa9, + 0x1f, 0x40, 0x3e, 0x18, 0xa0, 0xb, 0x51, 0xe1, + 0x0, + + /* U+00BD "½" */ + 0x2, 0xe4, 0x0, 0x0, 0x4c, 0x0, 0x3c, 0xd4, + 0x0, 0x0, 0xd2, 0x0, 0x0, 0xb4, 0x0, 0x9, + 0x70, 0x0, 0x0, 0xb4, 0x0, 0x4c, 0x0, 0x0, + 0x0, 0xb4, 0x1, 0xd2, 0x0, 0x0, 0x0, 0x0, + 0xa, 0x61, 0xbe, 0xa0, 0x0, 0x0, 0x5b, 0x6, + 0x70, 0xc5, 0x0, 0x1, 0xd2, 0x0, 0x1, 0xe3, + 0x0, 0xa, 0x60, 0x0, 0x1d, 0x70, 0x0, 0x5b, + 0x0, 0x1, 0xd6, 0x0, 0x1, 0xd1, 0x0, 0xa, + 0xff, 0xf6, 0x0, 0x10, 0x0, 0x1, 0x22, 0x20, + + /* U+0384 "΄" */ + 0x0, 0x10, 0xd, 0xa0, 0x4d, 0x0, + + /* U+0386 "Ά" */ + 0xe, 0x85, 0xf7, 0x0, 0x0, 0x6c, 0xa, 0xdd, + 0x0, 0x0, 0x0, 0xf, 0x5f, 0x30, 0x0, 0x0, + 0x6f, 0xd, 0x90, 0x0, 0x0, 0xba, 0x8, 0xe0, + 0x0, 0x1, 0xf5, 0x3, 0xf5, 0x0, 0x6, 0xf1, + 0x0, 0xeb, 0x0, 0xc, 0xff, 0xff, 0xff, 0x10, + 0x2f, 0x72, 0x22, 0x4f, 0x70, 0x7f, 0x0, 0x0, + 0xc, 0xd0, 0xd9, 0x0, 0x0, 0x5, 0xf3, + + /* U+0388 "Έ" */ + 0xe, 0x84, 0xff, 0xff, 0xff, 0xf0, 0x5c, 0x4, + 0xf4, 0x44, 0x44, 0x40, 0x0, 0x4, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x4, 0xf4, 0x33, + 0x33, 0x20, 0x0, 0x4, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xf5, 0x44, 0x44, 0x40, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xf3, + + /* U+0389 "Ή" */ + 0xe, 0x88, 0xc0, 0x0, 0x0, 0xf5, 0x5c, 0x8, + 0xc0, 0x0, 0x0, 0xf5, 0x0, 0x8, 0xc0, 0x0, + 0x0, 0xf5, 0x0, 0x8, 0xc0, 0x0, 0x0, 0xf5, + 0x0, 0x8, 0xc0, 0x0, 0x0, 0xf5, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xf5, 0x0, 0x8, 0xd3, 0x33, + 0x33, 0xf5, 0x0, 0x8, 0xc0, 0x0, 0x0, 0xf5, + 0x0, 0x8, 0xc0, 0x0, 0x0, 0xf5, 0x0, 0x8, + 0xc0, 0x0, 0x0, 0xf5, 0x0, 0x8, 0xc0, 0x0, + 0x0, 0xf5, + + /* U+038A "Ί" */ + 0xe, 0x88, 0xc5, 0xc0, 0x8c, 0x0, 0x8, 0xc0, + 0x0, 0x8c, 0x0, 0x8, 0xc0, 0x0, 0x8c, 0x0, + 0x8, 0xc0, 0x0, 0x8c, 0x0, 0x8, 0xc0, 0x0, + 0x8c, 0x0, 0x8, 0xc0, + + /* U+038C "Ό" */ + 0xe, 0x91, 0x9e, 0xfd, 0x70, 0x0, 0x4d, 0x2e, + 0xd5, 0x47, 0xeb, 0x0, 0x22, 0xbc, 0x0, 0x0, + 0x2f, 0x70, 0x1, 0xf4, 0x0, 0x0, 0x8, 0xe0, + 0x4, 0xf0, 0x0, 0x0, 0x5, 0xf1, 0x5, 0xf0, + 0x0, 0x0, 0x3, 0xf2, 0x4, 0xf1, 0x0, 0x0, + 0x5, 0xf1, 0x1, 0xf5, 0x0, 0x0, 0x8, 0xe0, + 0x0, 0xad, 0x0, 0x0, 0x2f, 0x70, 0x0, 0x1d, + 0xc5, 0x36, 0xec, 0x0, 0x0, 0x1, 0x9e, 0xfd, + 0x80, 0x0, + + /* U+038E "Ύ" */ + 0xe, 0x82, 0xf8, 0x0, 0x0, 0x1f, 0x75, 0xc0, + 0x7, 0xf2, 0x0, 0xa, 0xd0, 0x0, 0x0, 0xd, + 0xb0, 0x4, 0xf3, 0x0, 0x0, 0x0, 0x4f, 0x40, + 0xd9, 0x0, 0x0, 0x0, 0x0, 0xad, 0x7e, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8c, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8c, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xc0, 0x0, 0x0, + + /* U+038F "Ώ" */ + 0xe, 0x91, 0x9e, 0xfd, 0x60, 0x4, 0xd1, 0xdd, + 0x54, 0x8f, 0x80, 0x21, 0x9f, 0x10, 0x0, 0x6f, + 0x30, 0xe, 0x80, 0x0, 0x0, 0xe8, 0x1, 0xf5, + 0x0, 0x0, 0xb, 0xb0, 0x1f, 0x30, 0x0, 0x0, + 0x9b, 0x0, 0xf5, 0x0, 0x0, 0xb, 0x90, 0xa, + 0xa0, 0x0, 0x0, 0xf4, 0x0, 0x2f, 0x30, 0x0, + 0x8b, 0x0, 0x14, 0x9e, 0x40, 0x8f, 0x53, 0x4, + 0xff, 0xfa, 0xf, 0xff, 0xe0, + + /* U+0390 "ΐ" */ + 0xf4, 0xb8, 0xf0, 0x62, 0x40, 0x60, 0x0, 0x0, + 0x0, 0x1, 0xf2, 0x0, 0x1, 0xf2, 0x0, 0x1, + 0xf2, 0x0, 0x1, 0xf2, 0x0, 0x1, 0xf2, 0x0, + 0x1, 0xf2, 0x0, 0x1, 0xf2, 0x0, 0x1, 0xf2, + 0x0, + + /* U+0391 "Α" */ + 0x0, 0x5, 0xf7, 0x0, 0x0, 0x0, 0xa, 0xdd, + 0x0, 0x0, 0x0, 0xf, 0x5f, 0x30, 0x0, 0x0, + 0x6f, 0xd, 0x90, 0x0, 0x0, 0xba, 0x8, 0xe0, + 0x0, 0x1, 0xf5, 0x3, 0xf5, 0x0, 0x6, 0xf1, + 0x0, 0xeb, 0x0, 0xc, 0xff, 0xff, 0xff, 0x10, + 0x2f, 0x72, 0x22, 0x4f, 0x70, 0x7f, 0x0, 0x0, + 0xc, 0xd0, 0xd9, 0x0, 0x0, 0x5, 0xf3, + + /* U+0392 "Β" */ + 0xff, 0xff, 0xe9, 0x10, 0xf8, 0x44, 0x6d, 0xb0, + 0xf5, 0x0, 0x4, 0xf0, 0xf5, 0x0, 0x3, 0xf0, + 0xf6, 0x0, 0x2b, 0xb0, 0xff, 0xff, 0xff, 0x30, + 0xf8, 0x33, 0x5a, 0xf2, 0xf5, 0x0, 0x0, 0xe8, + 0xf5, 0x0, 0x0, 0xe8, 0xf8, 0x44, 0x5a, 0xf2, + 0xff, 0xff, 0xfc, 0x50, + + /* U+0393 "Γ" */ + 0xef, 0xff, 0xff, 0x6e, 0x94, 0x44, 0x41, 0xe7, + 0x0, 0x0, 0xe, 0x70, 0x0, 0x0, 0xe7, 0x0, + 0x0, 0xe, 0x70, 0x0, 0x0, 0xe7, 0x0, 0x0, + 0xe, 0x70, 0x0, 0x0, 0xe7, 0x0, 0x0, 0xe, + 0x70, 0x0, 0x0, 0xe7, 0x0, 0x0, 0x0, + + /* U+0394 "Δ" */ + 0x0, 0x0, 0x5f, 0x70, 0x0, 0x0, 0x0, 0xb, + 0xcd, 0x0, 0x0, 0x0, 0x1, 0xf4, 0xf3, 0x0, + 0x0, 0x0, 0x6e, 0xb, 0x90, 0x0, 0x0, 0xb, + 0x90, 0x6e, 0x0, 0x0, 0x1, 0xf3, 0x1, 0xf4, + 0x0, 0x0, 0x7e, 0x0, 0xb, 0xa0, 0x0, 0xc, + 0x90, 0x0, 0x6f, 0x10, 0x2, 0xf3, 0x0, 0x0, + 0xf6, 0x0, 0x7f, 0x44, 0x44, 0x4c, 0xc0, 0xd, + 0xff, 0xff, 0xff, 0xff, 0x20, + + /* U+0395 "Ε" */ + 0xef, 0xff, 0xff, 0xf5, 0xe9, 0x44, 0x44, 0x41, + 0xe7, 0x0, 0x0, 0x0, 0xe7, 0x0, 0x0, 0x0, + 0xe7, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xf0, + 0xe8, 0x33, 0x33, 0x30, 0xe7, 0x0, 0x0, 0x0, + 0xe7, 0x0, 0x0, 0x0, 0xe9, 0x44, 0x44, 0x42, + 0xef, 0xff, 0xff, 0xf9, + + /* U+0396 "Ζ" */ + 0x2f, 0xff, 0xff, 0xff, 0x0, 0x44, 0x44, 0x4e, + 0xd0, 0x0, 0x0, 0x8, 0xf2, 0x0, 0x0, 0x4, + 0xf6, 0x0, 0x0, 0x1, 0xea, 0x0, 0x0, 0x0, + 0xbd, 0x0, 0x0, 0x0, 0x7f, 0x30, 0x0, 0x0, + 0x3f, 0x70, 0x0, 0x0, 0xd, 0xb0, 0x0, 0x0, + 0x9, 0xf5, 0x44, 0x44, 0x40, 0xcf, 0xff, 0xff, + 0xff, 0x20, + + /* U+0397 "Η" */ + 0xe7, 0x0, 0x0, 0x5f, 0xe7, 0x0, 0x0, 0x5f, + 0xe7, 0x0, 0x0, 0x5f, 0xe7, 0x0, 0x0, 0x5f, + 0xe7, 0x0, 0x0, 0x5f, 0xef, 0xff, 0xff, 0xff, + 0xe9, 0x33, 0x33, 0x7f, 0xe7, 0x0, 0x0, 0x5f, + 0xe7, 0x0, 0x0, 0x5f, 0xe7, 0x0, 0x0, 0x5f, + 0xe7, 0x0, 0x0, 0x5f, + + /* U+0398 "Θ" */ + 0x0, 0x19, 0xef, 0xd8, 0x0, 0x0, 0x1d, 0xd6, + 0x46, 0xec, 0x0, 0xa, 0xd0, 0x0, 0x1, 0xf8, + 0x1, 0xf5, 0x0, 0x0, 0x8, 0xe0, 0x4f, 0x10, + 0x0, 0x0, 0x4f, 0x25, 0xf0, 0x8f, 0xff, 0x72, + 0xf3, 0x4f, 0x21, 0x33, 0x31, 0x4f, 0x20, 0xf6, + 0x0, 0x0, 0x7, 0xf0, 0xa, 0xd0, 0x0, 0x1, + 0xe8, 0x0, 0x1d, 0xd5, 0x36, 0xec, 0x0, 0x0, + 0x18, 0xdf, 0xd8, 0x0, 0x0, + + /* U+0399 "Ι" */ + 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, + 0xb9, 0xb9, 0xb9, + + /* U+039A "Κ" */ + 0xf5, 0x0, 0x2, 0xfa, 0xf, 0x50, 0x2, 0xeb, + 0x0, 0xf5, 0x1, 0xdb, 0x0, 0xf, 0x50, 0xcc, + 0x0, 0x0, 0xf6, 0xbf, 0x20, 0x0, 0xf, 0xed, + 0xe9, 0x0, 0x0, 0xfe, 0x15, 0xf4, 0x0, 0xf, + 0x60, 0xa, 0xe1, 0x0, 0xf5, 0x0, 0x1f, 0xa0, + 0xf, 0x50, 0x0, 0x6f, 0x40, 0xf5, 0x0, 0x0, + 0xce, 0x10, + + /* U+039B "Λ" */ + 0x0, 0x2, 0xf8, 0x0, 0x0, 0x0, 0x8, 0xde, + 0x0, 0x0, 0x0, 0xe, 0x4e, 0x30, 0x0, 0x0, + 0x4f, 0xa, 0x90, 0x0, 0x0, 0x9a, 0x5, 0xe0, + 0x0, 0x0, 0xe4, 0x0, 0xf4, 0x0, 0x5, 0xe0, + 0x0, 0xaa, 0x0, 0xa, 0x90, 0x0, 0x5f, 0x0, + 0xf, 0x40, 0x0, 0xf, 0x50, 0x6e, 0x0, 0x0, + 0xb, 0xb0, 0xb9, 0x0, 0x0, 0x5, 0xf1, + + /* U+039C "Μ" */ + 0xff, 0x30, 0x0, 0x5, 0xf9, 0xff, 0x80, 0x0, + 0xa, 0xf9, 0xfb, 0xc0, 0x0, 0xe, 0xc9, 0xf6, + 0xf1, 0x0, 0x4c, 0xa9, 0xf5, 0xc6, 0x0, 0x97, + 0xa9, 0xf5, 0x7b, 0x0, 0xe2, 0xa9, 0xf5, 0x2f, + 0x3, 0xd0, 0xa9, 0xf5, 0xd, 0x58, 0x80, 0xa9, + 0xf5, 0x8, 0xad, 0x30, 0xa9, 0xf5, 0x3, 0xfe, + 0x0, 0xa9, 0xf5, 0x0, 0xe9, 0x0, 0xa9, + + /* U+039D "Ν" */ + 0xec, 0x0, 0x0, 0x4f, 0xef, 0x60, 0x0, 0x4f, + 0xee, 0xe1, 0x0, 0x4f, 0xe6, 0xe9, 0x0, 0x4f, + 0xe6, 0x5f, 0x30, 0x4f, 0xe6, 0xb, 0xc0, 0x4f, + 0xe6, 0x2, 0xf6, 0x4f, 0xe6, 0x0, 0x7f, 0x5f, + 0xe6, 0x0, 0xd, 0xdf, 0xe6, 0x0, 0x4, 0xff, + 0xe6, 0x0, 0x0, 0xaf, + + /* U+039E "Ξ" */ + 0x1f, 0xff, 0xff, 0xff, 0x20, 0x44, 0x44, 0x44, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0x80, 0x1, 0x33, 0x33, 0x31, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x44, 0x44, 0x44, 0x41, 0x4f, 0xff, 0xff, + 0xff, 0x50, + + /* U+039F "Ο" */ + 0x0, 0x19, 0xef, 0xd8, 0x0, 0x0, 0x1d, 0xd6, + 0x46, 0xec, 0x0, 0xa, 0xd0, 0x0, 0x1, 0xf8, + 0x1, 0xf5, 0x0, 0x0, 0x8, 0xe0, 0x4f, 0x10, + 0x0, 0x0, 0x4f, 0x25, 0xf0, 0x0, 0x0, 0x2, + 0xf3, 0x4f, 0x20, 0x0, 0x0, 0x4f, 0x20, 0xf6, + 0x0, 0x0, 0x7, 0xf0, 0xa, 0xd0, 0x0, 0x1, + 0xe8, 0x0, 0x1d, 0xd5, 0x36, 0xec, 0x0, 0x0, + 0x18, 0xdf, 0xd8, 0x0, 0x0, + + /* U+03A0 "Π" */ + 0xef, 0xff, 0xff, 0xff, 0xe9, 0x44, 0x44, 0x8f, + 0xe7, 0x0, 0x0, 0x5f, 0xe7, 0x0, 0x0, 0x5f, + 0xe7, 0x0, 0x0, 0x5f, 0xe7, 0x0, 0x0, 0x5f, + 0xe7, 0x0, 0x0, 0x5f, 0xe7, 0x0, 0x0, 0x5f, + 0xe7, 0x0, 0x0, 0x5f, 0xe7, 0x0, 0x0, 0x5f, + 0xe7, 0x0, 0x0, 0x5f, + + /* U+03A1 "Ρ" */ + 0xef, 0xff, 0xfd, 0x60, 0xe9, 0x44, 0x48, 0xf5, + 0xe6, 0x0, 0x0, 0xca, 0xe6, 0x0, 0x0, 0xba, + 0xe6, 0x0, 0x16, 0xf6, 0xef, 0xff, 0xff, 0x90, + 0xe8, 0x33, 0x31, 0x0, 0xe6, 0x0, 0x0, 0x0, + 0xe6, 0x0, 0x0, 0x0, 0xe6, 0x0, 0x0, 0x0, + 0xe6, 0x0, 0x0, 0x0, + + /* U+03A3 "Σ" */ + 0xff, 0xff, 0xff, 0xd0, 0xdd, 0x44, 0x44, 0x30, + 0x2e, 0x70, 0x0, 0x0, 0x4, 0xf5, 0x0, 0x0, + 0x0, 0x6f, 0x30, 0x0, 0x0, 0xe, 0xa0, 0x0, + 0x0, 0xad, 0x0, 0x0, 0x7, 0xf3, 0x0, 0x0, + 0x3f, 0x60, 0x0, 0x0, 0xec, 0x44, 0x44, 0x40, + 0xff, 0xff, 0xff, 0xf1, + + /* U+03A4 "Τ" */ + 0xbf, 0xff, 0xff, 0xff, 0x42, 0x44, 0x8f, 0x44, + 0x41, 0x0, 0x6, 0xe0, 0x0, 0x0, 0x0, 0x6e, + 0x0, 0x0, 0x0, 0x6, 0xe0, 0x0, 0x0, 0x0, + 0x6e, 0x0, 0x0, 0x0, 0x6, 0xe0, 0x0, 0x0, + 0x0, 0x6e, 0x0, 0x0, 0x0, 0x6, 0xe0, 0x0, + 0x0, 0x0, 0x6e, 0x0, 0x0, 0x0, 0x6, 0xe0, + 0x0, 0x0, + + /* U+03A5 "Υ" */ + 0xae, 0x0, 0x0, 0x9, 0xe0, 0x1f, 0x80, 0x0, + 0x3f, 0x40, 0x6, 0xf2, 0x0, 0xca, 0x0, 0x0, + 0xcb, 0x6, 0xe1, 0x0, 0x0, 0x3f, 0x5e, 0x60, + 0x0, 0x0, 0x9, 0xfc, 0x0, 0x0, 0x0, 0x2, + 0xf4, 0x0, 0x0, 0x0, 0x1, 0xf3, 0x0, 0x0, + 0x0, 0x1, 0xf3, 0x0, 0x0, 0x0, 0x1, 0xf3, + 0x0, 0x0, 0x0, 0x1, 0xf3, 0x0, 0x0, + + /* U+03A6 "Φ" */ + 0x0, 0x0, 0x1f, 0x40, 0x0, 0x0, 0x4, 0xcf, + 0xff, 0xd7, 0x0, 0x5, 0xf9, 0x5f, 0x77, 0xf9, + 0x0, 0xe8, 0x1, 0xf4, 0x5, 0xf3, 0x4f, 0x10, + 0x1f, 0x40, 0xe, 0x76, 0xf0, 0x1, 0xf4, 0x0, + 0xc9, 0x5f, 0x10, 0x1f, 0x40, 0xe, 0x81, 0xf6, + 0x1, 0xf4, 0x3, 0xf3, 0x8, 0xf6, 0x2f, 0x44, + 0xeb, 0x0, 0x7, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x3f, 0x50, 0x0, 0x0, 0x0, 0x0, 0x82, + 0x0, 0x0, + + /* U+03A7 "Χ" */ + 0x2f, 0x60, 0x0, 0xc, 0xa0, 0x8, 0xf1, 0x0, + 0x8e, 0x0, 0x0, 0xdb, 0x3, 0xf4, 0x0, 0x0, + 0x3f, 0x5d, 0x90, 0x0, 0x0, 0x9, 0xfd, 0x0, + 0x0, 0x0, 0x4, 0xfa, 0x0, 0x0, 0x0, 0xd, + 0xcf, 0x40, 0x0, 0x0, 0x9e, 0xa, 0xe1, 0x0, + 0x4, 0xf4, 0x1, 0xe9, 0x0, 0xd, 0xa0, 0x0, + 0x5f, 0x40, 0x9e, 0x10, 0x0, 0xb, 0xd0, + + /* U+03A8 "Ψ" */ + 0x2f, 0x30, 0xd, 0x80, 0x8, 0xd2, 0xf3, 0x0, + 0xd8, 0x0, 0x8d, 0x2f, 0x30, 0xd, 0x80, 0x8, + 0xd1, 0xf3, 0x0, 0xd8, 0x0, 0x9c, 0xe, 0x70, + 0xd, 0x80, 0xd, 0xa0, 0x8f, 0x71, 0xd8, 0x2a, + 0xf3, 0x0, 0x8f, 0xff, 0xff, 0xe5, 0x0, 0x0, + 0x2, 0xd9, 0x10, 0x0, 0x0, 0x0, 0xd, 0x80, + 0x0, 0x0, 0x0, 0x0, 0xd8, 0x0, 0x0, 0x0, + 0x0, 0xd, 0x80, 0x0, 0x0, + + /* U+03A9 "Ω" */ + 0x0, 0x19, 0xef, 0xc5, 0x0, 0x1, 0xed, 0x54, + 0x8f, 0x70, 0xa, 0xe1, 0x0, 0x7, 0xf2, 0xf, + 0x70, 0x0, 0x0, 0xf7, 0x2f, 0x30, 0x0, 0x0, + 0xca, 0x3f, 0x20, 0x0, 0x0, 0xaa, 0x1f, 0x40, + 0x0, 0x0, 0xc8, 0xb, 0x80, 0x0, 0x1, 0xf3, + 0x3, 0xe2, 0x0, 0x9, 0xa0, 0x14, 0xae, 0x30, + 0x9e, 0x53, 0x5f, 0xff, 0x91, 0xff, 0xfd, + + /* U+03AA "Ϊ" */ + 0xf4, 0x7d, 0x82, 0x36, 0xb, 0x90, 0xb, 0x90, + 0xb, 0x90, 0xb, 0x90, 0xb, 0x90, 0xb, 0x90, + 0xb, 0x90, 0xb, 0x90, 0xb, 0x90, 0xb, 0x90, + 0xb, 0x90, + + /* U+03AB "Ϋ" */ + 0x0, 0x4f, 0xb, 0x90, 0x0, 0x0, 0x28, 0x5, + 0x40, 0x0, 0xae, 0x0, 0x0, 0x9, 0xe0, 0x1f, + 0x80, 0x0, 0x3f, 0x40, 0x6, 0xf2, 0x0, 0xca, + 0x0, 0x0, 0xcb, 0x6, 0xe1, 0x0, 0x0, 0x3f, + 0x5e, 0x60, 0x0, 0x0, 0x9, 0xfc, 0x0, 0x0, + 0x0, 0x2, 0xf4, 0x0, 0x0, 0x0, 0x1, 0xf3, + 0x0, 0x0, 0x0, 0x1, 0xf3, 0x0, 0x0, 0x0, + 0x1, 0xf3, 0x0, 0x0, 0x0, 0x1, 0xf3, 0x0, + 0x0, + + /* U+03AC "ά" */ + 0x0, 0x2, 0xf5, 0x0, 0x0, 0x9, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xcf, 0xd3, 0xd6, + 0xd, 0x90, 0x2d, 0xf3, 0x4f, 0x10, 0x8, 0xf0, + 0x7e, 0x0, 0x5, 0xc0, 0x7e, 0x0, 0x6, 0xc0, + 0x4f, 0x10, 0x9, 0xf0, 0xd, 0x90, 0x3d, 0xf2, + 0x2, 0xcf, 0xd3, 0xc6, + + /* U+03AD "έ" */ + 0x0, 0xe, 0x80, 0x0, 0x5c, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xdf, 0xb2, 0xf, 0x63, 0x82, 0xf, + 0x50, 0x0, 0x7, 0xff, 0x0, 0x1f, 0x82, 0x0, + 0x4f, 0x0, 0x0, 0x1f, 0x62, 0x99, 0x6, 0xef, + 0xb2, + + /* U+03AE "ή" */ + 0x0, 0x3, 0xf4, 0x0, 0x0, 0xa8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf6, 0xdf, 0xb1, 0xf, 0xc1, + 0x1c, 0x90, 0xf5, 0x0, 0x6c, 0xf, 0x30, 0x6, + 0xd0, 0xf3, 0x0, 0x6d, 0xf, 0x30, 0x6, 0xd0, + 0xf3, 0x0, 0x6d, 0xf, 0x30, 0x6, 0xd0, 0x0, + 0x0, 0x6d, 0x0, 0x0, 0x6, 0xd0, 0x0, 0x0, + 0x6d, + + /* U+03AF "ί" */ + 0x9, 0xd0, 0x1e, 0x30, 0x0, 0x0, 0x1f, 0x20, + 0x1f, 0x20, 0x1f, 0x20, 0x1f, 0x20, 0x1f, 0x20, + 0x1f, 0x20, 0x1f, 0x20, 0x1f, 0x20, + + /* U+03B0 "ΰ" */ + 0xa, 0x87, 0xad, 0x50, 0x43, 0x50, 0x52, 0x0, + 0x0, 0x0, 0x1, 0xf2, 0x0, 0x7b, 0x1f, 0x20, + 0x7, 0xb1, 0xf2, 0x0, 0x7b, 0x1f, 0x20, 0x7, + 0xb0, 0xf2, 0x0, 0x7b, 0xf, 0x40, 0x9, 0x90, + 0xbc, 0x24, 0xf4, 0x1, 0xbf, 0xe7, 0x0, + + /* U+03B1 "α" */ + 0x3, 0xcf, 0xd3, 0xd6, 0xd, 0x90, 0x2d, 0xf3, + 0x4f, 0x10, 0x8, 0xf0, 0x7e, 0x0, 0x5, 0xc0, + 0x7e, 0x0, 0x6, 0xc0, 0x4f, 0x10, 0x9, 0xf0, + 0xd, 0x90, 0x3d, 0xf2, 0x2, 0xcf, 0xd3, 0xc6, + + /* U+03B2 "β" */ + 0x0, 0x9e, 0xe8, 0x0, 0xa, 0xc3, 0x3e, 0x60, + 0xf, 0x40, 0x6, 0xb0, 0xf, 0x30, 0x6, 0xb0, + 0xf, 0x30, 0x3d, 0x40, 0xf, 0x3b, 0xf9, 0x0, + 0xf, 0x30, 0x1a, 0xd0, 0xf, 0x30, 0x0, 0xf5, + 0xf, 0x60, 0x0, 0xe5, 0xf, 0xe3, 0x7, 0xe1, + 0xf, 0x6d, 0xfc, 0x30, 0xf, 0x30, 0x0, 0x0, + 0xf, 0x30, 0x0, 0x0, 0xf, 0x30, 0x0, 0x0, + + /* U+03B3 "γ" */ + 0xaa, 0x0, 0x9, 0xa5, 0xe0, 0x0, 0xe5, 0xf, + 0x40, 0x4f, 0x0, 0xa9, 0x9, 0xa0, 0x4, 0xe0, + 0xe4, 0x0, 0xf, 0x7e, 0x0, 0x0, 0xaf, 0x90, + 0x0, 0x4, 0xf4, 0x0, 0x0, 0x2f, 0x10, 0x0, + 0x2, 0xf1, 0x0, 0x0, 0x2f, 0x10, 0x0, + + /* U+03B4 "δ" */ + 0xc, 0xff, 0xff, 0xa0, 0x4, 0xf6, 0x11, 0x0, + 0x0, 0x3e, 0x70, 0x0, 0x2, 0xcf, 0xfa, 0x0, + 0xd, 0xa1, 0x2c, 0x90, 0x4f, 0x10, 0x3, 0xf1, + 0x7c, 0x0, 0x0, 0xf3, 0x6d, 0x0, 0x0, 0xf3, + 0x3f, 0x10, 0x4, 0xf1, 0xc, 0xc2, 0x3d, 0x90, + 0x1, 0xbf, 0xe9, 0x0, + + /* U+03B5 "ε" */ + 0x5, 0xdf, 0xb2, 0xf, 0x63, 0x82, 0xf, 0x50, + 0x0, 0x7, 0xff, 0x0, 0x1f, 0x82, 0x0, 0x4f, + 0x0, 0x0, 0x1f, 0x62, 0x99, 0x6, 0xef, 0xb2, + + /* U+03B6 "ζ" */ + 0x6, 0xff, 0xff, 0x0, 0x1, 0x3e, 0x60, 0x0, + 0x2e, 0x40, 0x0, 0xc, 0x70, 0x0, 0x8, 0xb0, + 0x0, 0x0, 0xf3, 0x0, 0x0, 0x5e, 0x0, 0x0, + 0x7, 0xb0, 0x0, 0x0, 0x6d, 0x0, 0x0, 0x2, + 0xfa, 0x63, 0x0, 0x7, 0xef, 0xf8, 0x0, 0x0, + 0x7, 0xe0, 0x0, 0x1, 0x9b, 0x0, 0x0, 0x8b, + 0x10, + + /* U+03B7 "η" */ + 0xf, 0x6d, 0xfb, 0x10, 0xfc, 0x11, 0xc9, 0xf, + 0x50, 0x6, 0xc0, 0xf3, 0x0, 0x6d, 0xf, 0x30, + 0x6, 0xd0, 0xf3, 0x0, 0x6d, 0xf, 0x30, 0x6, + 0xd0, 0xf3, 0x0, 0x6d, 0x0, 0x0, 0x6, 0xd0, + 0x0, 0x0, 0x6d, 0x0, 0x0, 0x6, 0xd0, + + /* U+03B8 "θ" */ + 0x0, 0xaf, 0xe7, 0x0, 0x9, 0xd3, 0x4f, 0x60, + 0xf, 0x40, 0x7, 0xc0, 0x3f, 0x0, 0x3, 0xf0, + 0x5f, 0x0, 0x2, 0xf2, 0x5f, 0xff, 0xff, 0xf2, + 0x5f, 0x22, 0x24, 0xf2, 0x3f, 0x0, 0x3, 0xf0, + 0xf, 0x40, 0x7, 0xc0, 0x9, 0xd3, 0x4e, 0x60, + 0x0, 0xaf, 0xe7, 0x0, + + /* U+03B9 "ι" */ + 0x1f, 0x21, 0xf2, 0x1f, 0x21, 0xf2, 0x1f, 0x21, + 0xf2, 0x1f, 0x21, 0xf2, + + /* U+03BA "κ" */ + 0x1f, 0x20, 0x6f, 0x41, 0xf2, 0x5f, 0x40, 0x1f, + 0x6f, 0x40, 0x1, 0xff, 0xb0, 0x0, 0x1f, 0x8f, + 0x50, 0x1, 0xf2, 0x7f, 0x20, 0x1f, 0x20, 0xbd, + 0x1, 0xf2, 0x1, 0xe9, + + /* U+03BB "λ" */ + 0x1, 0xf3, 0x0, 0x0, 0xb, 0x90, 0x0, 0x0, + 0x6e, 0x0, 0x0, 0x4, 0xf4, 0x0, 0x0, 0x9f, + 0x90, 0x0, 0xe, 0xce, 0x0, 0x4, 0xf1, 0xf4, + 0x0, 0xaa, 0xa, 0xa0, 0xf, 0x50, 0x5f, 0x5, + 0xf0, 0x0, 0xf5, 0xaa, 0x0, 0xa, 0xa0, + + /* U+03BC "μ" */ + 0xf, 0x20, 0x6, 0xd0, 0xf2, 0x0, 0x6d, 0xf, + 0x20, 0x6, 0xd0, 0xf2, 0x0, 0x6d, 0xf, 0x30, + 0x6, 0xd0, 0xf4, 0x0, 0x8d, 0xf, 0xc1, 0x3e, + 0xd0, 0xf9, 0xed, 0x9d, 0xf, 0x20, 0x0, 0x0, + 0xf2, 0x0, 0x0, 0xf, 0x20, 0x0, 0x0, + + /* U+03BD "ν" */ + 0xaa, 0x0, 0x9, 0xa5, 0xf0, 0x0, 0xe5, 0xf, + 0x40, 0x4f, 0x0, 0x99, 0x9, 0xa0, 0x4, 0xe0, + 0xe4, 0x0, 0xe, 0x7e, 0x0, 0x0, 0x9f, 0x90, + 0x0, 0x3, 0xf4, 0x0, + + /* U+03BE "ξ" */ + 0x1, 0xae, 0xf4, 0x0, 0xbb, 0x31, 0x0, 0xf, + 0x30, 0x0, 0x0, 0xc8, 0x0, 0x0, 0x2, 0xbf, + 0xf3, 0x0, 0x3e, 0x83, 0x0, 0xe, 0x60, 0x0, + 0x4, 0xf0, 0x0, 0x0, 0x4f, 0x0, 0x0, 0x1, + 0xea, 0x30, 0x0, 0x2, 0xae, 0xf6, 0x0, 0x0, + 0x6, 0xe0, 0x0, 0x1, 0x9d, 0x0, 0x0, 0x9c, + 0x20, + + /* U+03BF "ο" */ + 0x1, 0xae, 0xe9, 0x0, 0xd, 0xb2, 0x3d, 0x90, + 0x5f, 0x10, 0x4, 0xf1, 0x7c, 0x0, 0x0, 0xf3, + 0x7c, 0x0, 0x0, 0xf4, 0x5f, 0x10, 0x4, 0xf1, + 0xd, 0xb2, 0x3d, 0xa0, 0x1, 0xae, 0xe9, 0x0, + + /* U+03C0 "π" */ + 0xbf, 0xff, 0xff, 0xff, 0xf5, 0x1, 0xc7, 0x11, + 0x9b, 0x10, 0x0, 0xc7, 0x0, 0x8b, 0x0, 0x0, + 0xc7, 0x0, 0x8b, 0x0, 0x0, 0xc7, 0x0, 0x8b, + 0x0, 0x0, 0xc7, 0x0, 0x8b, 0x0, 0x0, 0xc7, + 0x0, 0x8b, 0x0, 0x0, 0xc7, 0x0, 0x8b, 0x0, + + /* U+03C1 "ρ" */ + 0x0, 0x9e, 0xfa, 0x10, 0x8, 0xe4, 0x2b, 0xc0, + 0xe, 0x60, 0x1, 0xf3, 0xf, 0x30, 0x0, 0xd6, + 0x1f, 0x20, 0x0, 0xd6, 0x1f, 0x50, 0x1, 0xf3, + 0x1f, 0xd3, 0x2b, 0xc0, 0x1f, 0x7d, 0xfb, 0x10, + 0x1f, 0x20, 0x0, 0x0, 0x1f, 0x20, 0x0, 0x0, + 0x1f, 0x20, 0x0, 0x0, + + /* U+03C2 "ς" */ + 0x0, 0x4c, 0xfe, 0x60, 0x6e, 0x62, 0x31, 0xf, + 0x40, 0x0, 0x5, 0xe0, 0x0, 0x0, 0x5d, 0x0, + 0x0, 0x2, 0xf3, 0x0, 0x0, 0x9, 0xf9, 0x30, + 0x0, 0x5, 0xbf, 0xb0, 0x0, 0x0, 0x2f, 0x30, + 0x0, 0x48, 0xf1, 0x0, 0x4f, 0xd4, 0x0, + + /* U+03C3 "σ" */ + 0x1, 0xae, 0xff, 0xff, 0x50, 0xec, 0x56, 0xea, + 0x41, 0x5f, 0x10, 0x5, 0xf0, 0x8, 0xc0, 0x0, + 0xf, 0x30, 0x7c, 0x0, 0x0, 0xf3, 0x4, 0xf0, + 0x0, 0x4f, 0x10, 0xd, 0xa2, 0x3d, 0xa0, 0x0, + 0x1a, 0xee, 0x80, 0x0, + + /* U+03C4 "τ" */ + 0xbf, 0xff, 0xf3, 0x1, 0xc7, 0x10, 0x0, 0xc7, + 0x0, 0x0, 0xc7, 0x0, 0x0, 0xc7, 0x0, 0x0, + 0xc7, 0x0, 0x0, 0xc7, 0x0, 0x0, 0xc7, 0x0, + + /* U+03C5 "υ" */ + 0x1f, 0x20, 0x7, 0xb1, 0xf2, 0x0, 0x7b, 0x1f, + 0x20, 0x7, 0xb1, 0xf2, 0x0, 0x7b, 0xf, 0x20, + 0x7, 0xb0, 0xf4, 0x0, 0x99, 0xb, 0xc2, 0x4f, + 0x40, 0x1b, 0xfe, 0x70, + + /* U+03C6 "φ" */ + 0x2, 0xc4, 0x9f, 0xd4, 0x0, 0xd9, 0xf, 0x66, + 0xe1, 0x4e, 0x0, 0xf3, 0xd, 0x67, 0xc0, 0xf, + 0x30, 0xb9, 0x7d, 0x0, 0xf3, 0xd, 0x73, 0xf3, + 0xf, 0x33, 0xf2, 0xa, 0xe5, 0xf7, 0xe9, 0x0, + 0x8, 0xef, 0xe7, 0x0, 0x0, 0x0, 0xf3, 0x0, + 0x0, 0x0, 0xf, 0x30, 0x0, 0x0, 0x0, 0xf3, + 0x0, 0x0, + + /* U+03C7 "χ" */ + 0x7e, 0x0, 0x8, 0xd0, 0xe, 0x50, 0xe, 0x50, + 0x7, 0xc0, 0x7d, 0x0, 0x1, 0xf4, 0xe5, 0x0, + 0x0, 0x8e, 0xd0, 0x0, 0x0, 0x3f, 0x80, 0x0, + 0x0, 0x9d, 0xe0, 0x0, 0x2, 0xf2, 0xd7, 0x0, + 0xa, 0xa0, 0x5e, 0x0, 0x2f, 0x30, 0xd, 0x70, + 0xab, 0x0, 0x6, 0xe0, + + /* U+03C8 "ψ" */ + 0x2f, 0x10, 0xa9, 0x1, 0xf2, 0x2f, 0x10, 0xa9, + 0x1, 0xf2, 0x2f, 0x10, 0xa9, 0x1, 0xf2, 0x2f, + 0x10, 0xa9, 0x1, 0xf2, 0x2f, 0x10, 0xa9, 0x1, + 0xf1, 0xf, 0x30, 0xa9, 0x4, 0xf0, 0xa, 0xd4, + 0xaa, 0x4d, 0xa0, 0x0, 0x9d, 0xff, 0xe9, 0x0, + 0x0, 0x0, 0xa9, 0x0, 0x0, 0x0, 0x0, 0xa9, + 0x0, 0x0, 0x0, 0x0, 0xa9, 0x0, 0x0, + + /* U+03C9 "ω" */ + 0x8, 0xa0, 0x0, 0x0, 0xc7, 0x0, 0xe5, 0x0, + 0x0, 0x6, 0xe0, 0x3f, 0x0, 0x2f, 0x10, 0x2f, + 0x25, 0xe0, 0x2, 0xf1, 0x0, 0xf4, 0x5e, 0x0, + 0x2f, 0x10, 0xf, 0x43, 0xf1, 0x4, 0xf2, 0x1, + 0xf2, 0xd, 0x91, 0xbb, 0xa1, 0xac, 0x0, 0x3d, + 0xf8, 0x9, 0xfd, 0x20, + + /* U+03CA "ϊ" */ + 0x6e, 0xd, 0x73, 0x70, 0x63, 0x0, 0x0, 0x0, + 0x1f, 0x20, 0x1, 0xf2, 0x0, 0x1f, 0x20, 0x1, + 0xf2, 0x0, 0x1f, 0x20, 0x1, 0xf2, 0x0, 0x1f, + 0x20, 0x1, 0xf2, 0x0, + + /* U+03CB "ϋ" */ + 0x1, 0xf3, 0x8c, 0x0, 0x8, 0x14, 0x60, 0x0, + 0x0, 0x0, 0x1, 0xf2, 0x0, 0x7b, 0x1f, 0x20, + 0x7, 0xb1, 0xf2, 0x0, 0x7b, 0x1f, 0x20, 0x7, + 0xb0, 0xf2, 0x0, 0x7b, 0xf, 0x40, 0x9, 0x90, + 0xbc, 0x24, 0xf4, 0x1, 0xbf, 0xe7, 0x0, + + /* U+03CC "ό" */ + 0x0, 0x3, 0xf4, 0x0, 0x0, 0xa, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xae, 0xe9, 0x0, + 0xd, 0xb2, 0x3d, 0x90, 0x5f, 0x10, 0x4, 0xf1, + 0x7c, 0x0, 0x0, 0xf3, 0x7c, 0x0, 0x0, 0xf4, + 0x5f, 0x10, 0x4, 0xf1, 0xd, 0xb2, 0x3d, 0xa0, + 0x1, 0xae, 0xe9, 0x0, + + /* U+03CD "ύ" */ + 0x0, 0x4, 0xf3, 0x0, 0x0, 0xb7, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xf2, 0x0, 0x7b, 0x1f, 0x20, + 0x7, 0xb1, 0xf2, 0x0, 0x7b, 0x1f, 0x20, 0x7, + 0xb0, 0xf2, 0x0, 0x7b, 0xf, 0x40, 0x9, 0x90, + 0xbc, 0x24, 0xf4, 0x1, 0xbf, 0xe7, 0x0, + + /* U+03CE "ώ" */ + 0x0, 0x0, 0xa, 0xc0, 0x0, 0x0, 0x0, 0x1, + 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8a, 0x0, 0x0, 0xc, 0x70, 0xe, 0x50, + 0x0, 0x0, 0x6e, 0x3, 0xf0, 0x2, 0xf1, 0x2, + 0xf2, 0x5e, 0x0, 0x2f, 0x10, 0xf, 0x45, 0xe0, + 0x2, 0xf1, 0x0, 0xf4, 0x3f, 0x10, 0x4f, 0x20, + 0x1f, 0x20, 0xd9, 0x1b, 0xba, 0x1a, 0xc0, 0x3, + 0xdf, 0x80, 0x9f, 0xd2, 0x0, + + /* U+03F4 "ϴ" */ + 0x2f, 0x1d, 0x9d, 0x16, 0x23, 0x25 +}; + + +/*--------------------- + * GLYPH DESCRIPTION + *--------------------*/ + +static const lv_font_fmt_txt_glyph_dsc_t glyph_dsc[] = { + {.bitmap_index = 0, .adv_w = 0, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0} /* id = 0 reserved */, + {.bitmap_index = 0, .adv_w = 62, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 0, .adv_w = 62, .box_w = 2, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 11, .adv_w = 79, .box_w = 5, .box_h = 4, .ofs_x = 0, .ofs_y = 7}, + {.bitmap_index = 21, .adv_w = 125, .box_w = 8, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 65, .adv_w = 125, .box_w = 8, .box_h = 14, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 121, .adv_w = 199, .box_w = 12, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 187, .adv_w = 150, .box_w = 10, .box_h = 12, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 247, .adv_w = 42, .box_w = 3, .box_h = 4, .ofs_x = 0, .ofs_y = 7}, + {.bitmap_index = 253, .adv_w = 75, .box_w = 5, .box_h = 14, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 288, .adv_w = 75, .box_w = 4, .box_h = 14, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 316, .adv_w = 87, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 6}, + {.bitmap_index = 329, .adv_w = 131, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 2}, + {.bitmap_index = 361, .adv_w = 62, .box_w = 2, .box_h = 5, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 366, .adv_w = 75, .box_w = 5, .box_h = 3, .ofs_x = 0, .ofs_y = 3}, + {.bitmap_index = 374, .adv_w = 62, .box_w = 2, .box_h = 2, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 376, .adv_w = 62, .box_w = 4, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 398, .adv_w = 125, .box_w = 8, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 442, .adv_w = 125, .box_w = 5, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 470, .adv_w = 125, .box_w = 8, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 514, .adv_w = 125, .box_w = 8, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 558, .adv_w = 125, .box_w = 8, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 602, .adv_w = 125, .box_w = 8, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 646, .adv_w = 125, .box_w = 8, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 690, .adv_w = 125, .box_w = 8, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 734, .adv_w = 125, .box_w = 8, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 778, .adv_w = 125, .box_w = 8, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 822, .adv_w = 62, .box_w = 2, .box_h = 8, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 830, .adv_w = 62, .box_w = 2, .box_h = 11, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 841, .adv_w = 131, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 1}, + {.bitmap_index = 873, .adv_w = 131, .box_w = 8, .box_h = 5, .ofs_x = 0, .ofs_y = 3}, + {.bitmap_index = 893, .adv_w = 131, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 1}, + {.bitmap_index = 925, .adv_w = 125, .box_w = 8, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 969, .adv_w = 227, .box_w = 14, .box_h = 14, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 1067, .adv_w = 150, .box_w = 10, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1122, .adv_w = 150, .box_w = 8, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1166, .adv_w = 162, .box_w = 10, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1221, .adv_w = 162, .box_w = 9, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1271, .adv_w = 150, .box_w = 8, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1315, .adv_w = 137, .box_w = 7, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1354, .adv_w = 174, .box_w = 10, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1409, .adv_w = 162, .box_w = 8, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1453, .adv_w = 62, .box_w = 2, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1464, .adv_w = 112, .box_w = 6, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1497, .adv_w = 150, .box_w = 9, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1547, .adv_w = 125, .box_w = 7, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1586, .adv_w = 187, .box_w = 10, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1641, .adv_w = 162, .box_w = 8, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1685, .adv_w = 174, .box_w = 11, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1746, .adv_w = 150, .box_w = 8, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1790, .adv_w = 174, .box_w = 11, .box_h = 12, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 1856, .adv_w = 162, .box_w = 9, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1906, .adv_w = 150, .box_w = 9, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1956, .adv_w = 137, .box_w = 9, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2006, .adv_w = 162, .box_w = 8, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2050, .adv_w = 150, .box_w = 10, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2105, .adv_w = 211, .box_w = 14, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2182, .adv_w = 150, .box_w = 10, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2237, .adv_w = 150, .box_w = 10, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2292, .adv_w = 137, .box_w = 9, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2342, .adv_w = 62, .box_w = 4, .box_h = 14, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 2370, .adv_w = 62, .box_w = 4, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2392, .adv_w = 62, .box_w = 3, .box_h = 14, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 2413, .adv_w = 105, .box_w = 7, .box_h = 6, .ofs_x = 0, .ofs_y = 5}, + {.bitmap_index = 2434, .adv_w = 125, .box_w = 9, .box_h = 1, .ofs_x = -1, .ofs_y = -3}, + {.bitmap_index = 2439, .adv_w = 75, .box_w = 4, .box_h = 3, .ofs_x = 0, .ofs_y = 9}, + {.bitmap_index = 2445, .adv_w = 125, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2477, .adv_w = 125, .box_w = 8, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2521, .adv_w = 112, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2549, .adv_w = 125, .box_w = 7, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2588, .adv_w = 125, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2620, .adv_w = 62, .box_w = 5, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2648, .adv_w = 125, .box_w = 7, .box_h = 11, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 2687, .adv_w = 125, .box_w = 7, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2726, .adv_w = 50, .box_w = 3, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2743, .adv_w = 50, .box_w = 4, .box_h = 14, .ofs_x = -1, .ofs_y = -3}, + {.bitmap_index = 2771, .adv_w = 112, .box_w = 7, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2810, .adv_w = 50, .box_w = 3, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2827, .adv_w = 187, .box_w = 11, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2871, .adv_w = 125, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2899, .adv_w = 125, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2931, .adv_w = 125, .box_w = 8, .box_h = 11, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 2975, .adv_w = 125, .box_w = 7, .box_h = 11, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 3014, .adv_w = 75, .box_w = 5, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3034, .adv_w = 112, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3062, .adv_w = 62, .box_w = 4, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3084, .adv_w = 125, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3112, .adv_w = 112, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3140, .adv_w = 162, .box_w = 11, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3184, .adv_w = 112, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3212, .adv_w = 112, .box_w = 7, .box_h = 11, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 3251, .adv_w = 112, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3279, .adv_w = 75, .box_w = 5, .box_h = 14, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 3314, .adv_w = 58, .box_w = 2, .box_h = 14, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 3328, .adv_w = 75, .box_w = 5, .box_h = 14, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 3363, .adv_w = 131, .box_w = 8, .box_h = 4, .ofs_x = 0, .ofs_y = 3}, + {.bitmap_index = 3379, .adv_w = 62, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3379, .adv_w = 125, .box_w = 8, .box_h = 12, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 3427, .adv_w = 125, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 1}, + {.bitmap_index = 3459, .adv_w = 125, .box_w = 8, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3503, .adv_w = 58, .box_w = 2, .box_h = 14, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 3517, .adv_w = 125, .box_w = 8, .box_h = 14, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 3573, .adv_w = 75, .box_w = 5, .box_h = 2, .ofs_x = 0, .ofs_y = 9}, + {.bitmap_index = 3578, .adv_w = 165, .box_w = 11, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3639, .adv_w = 84, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 5}, + {.bitmap_index = 3654, .adv_w = 125, .box_w = 7, .box_h = 7, .ofs_x = 0, .ofs_y = 1}, + {.bitmap_index = 3679, .adv_w = 131, .box_w = 8, .box_h = 5, .ofs_x = 0, .ofs_y = 3}, + {.bitmap_index = 3699, .adv_w = 75, .box_w = 5, .box_h = 3, .ofs_x = 0, .ofs_y = 3}, + {.bitmap_index = 3707, .adv_w = 165, .box_w = 11, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3768, .adv_w = 90, .box_w = 5, .box_h = 4, .ofs_x = 0, .ofs_y = 7}, + {.bitmap_index = 3778, .adv_w = 131, .box_w = 8, .box_h = 9, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3814, .adv_w = 75, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 5}, + {.bitmap_index = 3827, .adv_w = 75, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 5}, + {.bitmap_index = 3840, .adv_w = 125, .box_w = 7, .box_h = 11, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 3879, .adv_w = 120, .box_w = 9, .box_h = 14, .ofs_x = -1, .ofs_y = -3}, + {.bitmap_index = 3942, .adv_w = 63, .box_w = 2, .box_h = 2, .ofs_x = 1, .ofs_y = 5}, + {.bitmap_index = 3944, .adv_w = 125, .box_w = 7, .box_h = 7, .ofs_x = 0, .ofs_y = 1}, + {.bitmap_index = 3969, .adv_w = 187, .box_w = 12, .box_h = 12, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 4041, .adv_w = 75, .box_w = 4, .box_h = 3, .ofs_x = 1, .ofs_y = 9}, + {.bitmap_index = 4047, .adv_w = 150, .box_w = 10, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4102, .adv_w = 176, .box_w = 12, .box_h = 11, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 4168, .adv_w = 188, .box_w = 12, .box_h = 11, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 4234, .adv_w = 86, .box_w = 5, .box_h = 11, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 4262, .adv_w = 173, .box_w = 12, .box_h = 11, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 4328, .adv_w = 192, .box_w = 13, .box_h = 11, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 4400, .adv_w = 169, .box_w = 11, .box_h = 11, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 4461, .adv_w = 50, .box_w = 6, .box_h = 11, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 4494, .adv_w = 150, .box_w = 10, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4549, .adv_w = 150, .box_w = 8, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4593, .adv_w = 123, .box_w = 7, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4632, .adv_w = 150, .box_w = 11, .box_h = 11, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 4693, .adv_w = 150, .box_w = 8, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4737, .adv_w = 137, .box_w = 9, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4787, .adv_w = 162, .box_w = 8, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4831, .adv_w = 174, .box_w = 11, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4892, .adv_w = 62, .box_w = 2, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4903, .adv_w = 150, .box_w = 9, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4953, .adv_w = 150, .box_w = 10, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5008, .adv_w = 187, .box_w = 10, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 5063, .adv_w = 162, .box_w = 8, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 5107, .adv_w = 146, .box_w = 9, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5157, .adv_w = 174, .box_w = 11, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5218, .adv_w = 162, .box_w = 8, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 5262, .adv_w = 150, .box_w = 8, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 5306, .adv_w = 138, .box_w = 8, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 5350, .adv_w = 137, .box_w = 9, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5400, .adv_w = 150, .box_w = 10, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5455, .adv_w = 179, .box_w = 11, .box_h = 12, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 5521, .adv_w = 150, .box_w = 10, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5576, .adv_w = 187, .box_w = 11, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5637, .adv_w = 167, .box_w = 10, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5692, .adv_w = 62, .box_w = 4, .box_h = 13, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5718, .adv_w = 150, .box_w = 10, .box_h = 13, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5783, .adv_w = 130, .box_w = 8, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5827, .adv_w = 100, .box_w = 6, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5860, .adv_w = 125, .box_w = 7, .box_h = 14, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 5909, .adv_w = 50, .box_w = 4, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5931, .adv_w = 123, .box_w = 7, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5970, .adv_w = 130, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6002, .adv_w = 129, .box_w = 8, .box_h = 14, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 6058, .adv_w = 112, .box_w = 7, .box_h = 11, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 6097, .adv_w = 125, .box_w = 8, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6141, .adv_w = 100, .box_w = 6, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6165, .adv_w = 99, .box_w = 7, .box_h = 14, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 6214, .adv_w = 125, .box_w = 7, .box_h = 11, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 6253, .adv_w = 125, .box_w = 8, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6297, .adv_w = 50, .box_w = 3, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6309, .adv_w = 112, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6337, .adv_w = 112, .box_w = 7, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6376, .adv_w = 125, .box_w = 7, .box_h = 11, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 6415, .adv_w = 112, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6443, .adv_w = 100, .box_w = 7, .box_h = 14, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 6492, .adv_w = 125, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6524, .adv_w = 155, .box_w = 10, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6564, .adv_w = 127, .box_w = 8, .box_h = 11, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 6608, .adv_w = 108, .box_w = 7, .box_h = 11, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 6647, .adv_w = 138, .box_w = 9, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6683, .adv_w = 88, .box_w = 6, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6707, .adv_w = 123, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6735, .adv_w = 145, .box_w = 9, .box_h = 11, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 6785, .adv_w = 118, .box_w = 8, .box_h = 11, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 6829, .adv_w = 160, .box_w = 10, .box_h = 11, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 6884, .adv_w = 175, .box_w = 11, .box_h = 8, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6928, .adv_w = 50, .box_w = 5, .box_h = 11, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 6956, .adv_w = 123, .box_w = 7, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6995, .adv_w = 125, .box_w = 8, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7039, .adv_w = 123, .box_w = 7, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7078, .adv_w = 175, .box_w = 11, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7139, .adv_w = 75, .box_w = 6, .box_h = 2, .ofs_x = -1, .ofs_y = 9} +}; + +/*--------------------- + * CHARACTER MAPPING + *--------------------*/ + +static const uint8_t glyph_id_ofs_list_1[] = { + 0, 0, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 0, + 13, 14, 15, 16, 0, 17, 18, 19, + 0, 0, 0, 20, 0, 21 +}; + +static const uint8_t glyph_id_ofs_list_2[] = { + 0, 0, 1, 0, 2, 3, 4, 0, + 5 +}; + +/*Collect the unicode lists and glyph_id offsets*/ +static const lv_font_fmt_txt_cmap_t cmaps[] = +{ + { + .range_start = 32, .range_length = 95, .glyph_id_start = 1, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 160, .range_length = 30, .glyph_id_start = 96, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_1, .list_length = 30, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 900, .range_length = 9, .glyph_id_start = 118, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_2, .list_length = 9, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 910, .range_length = 20, .glyph_id_start = 124, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 931, .range_length = 44, .glyph_id_start = 144, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 1012, .range_length = 1, .glyph_id_start = 188, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + } +}; + + + +/*-------------------- + * ALL CUSTOM DATA + *--------------------*/ + +#if LVGL_VERSION_MAJOR == 8 +/*Store all the custom data of the font*/ +static lv_font_fmt_txt_glyph_cache_t cache; +#endif + +#if LVGL_VERSION_MAJOR >= 8 +static const lv_font_fmt_txt_dsc_t font_dsc = { +#else +static lv_font_fmt_txt_dsc_t font_dsc = { +#endif + .glyph_bitmap = glyph_bitmap, + .glyph_dsc = glyph_dsc, + .cmaps = cmaps, + .kern_dsc = NULL, + .kern_scale = 0, + .cmap_num = 6, + .bpp = 4, + .kern_classes = 0, + .bitmap_format = 0, +#if LVGL_VERSION_MAJOR == 8 + .cache = &cache +#endif + +}; + +extern const lv_font_t lv_font_montserrat_14; + + +/*----------------- + * PUBLIC FONT + *----------------*/ + +/*Initialize a public general font descriptor*/ +#if LVGL_VERSION_MAJOR >= 8 +const lv_font_t lv_font_arial_14 = { +#else +lv_font_t lv_font_arial_14 = { +#endif + .get_glyph_dsc = lv_font_get_glyph_dsc_fmt_txt, /*Function pointer to get glyph's data*/ + .get_glyph_bitmap = lv_font_get_bitmap_fmt_txt, /*Function pointer to get glyph's bitmap*/ + .line_height = 16, /*The maximum line height required by the font*/ + .base_line = 3, /*Baseline measured from the bottom of the line*/ +#if !(LVGL_VERSION_MAJOR == 6 && LVGL_VERSION_MINOR == 0) + .subpx = LV_FONT_SUBPX_NONE, +#endif +#if LV_VERSION_CHECK(7, 4, 0) || LVGL_VERSION_MAJOR >= 8 + .underline_position = -1, + .underline_thickness = 1, +#endif + //.static_bitmap = 0, + .dsc = &font_dsc, /*The custom font data. Will be accessed by `get_glyph_bitmap/dsc` */ +#if LV_VERSION_CHECK(8, 2, 0) || LVGL_VERSION_MAJOR >= 9 + .fallback = &lv_font_montserrat_14, +#endif + .user_data = NULL, +}; + + + +#endif /*#if LV_FONT_ARIAL_14*/ diff --git a/src/fonts/lv_font_arial_16.c b/src/fonts/lv_font_arial_16.c new file mode 100644 index 0000000000..6cc66dc38d --- /dev/null +++ b/src/fonts/lv_font_arial_16.c @@ -0,0 +1,1881 @@ +/******************************************************************************* + * Size: 16 px + * Bpp: 4 + * Opts: --bpp 4 --size 16 --no-compress --stride 1 --align 1 --font Arial Greek Regular.ttf --range 32-127,160-255,880-1023 --format lvgl -o lv_font_arial_16.c + ******************************************************************************/ + +#ifdef __has_include + #if __has_include("lvgl.h") + #ifndef LV_LVGL_H_INCLUDE_SIMPLE + #define LV_LVGL_H_INCLUDE_SIMPLE + #endif + #endif +#endif + +#ifdef LV_LVGL_H_INCLUDE_SIMPLE + #include "lvgl.h" +#else + #include "lvgl/lvgl.h" +#endif + + + +#ifndef LV_FONT_ARIAL_16 +#define LV_FONT_ARIAL_16 1 +#endif + +#if LV_FONT_ARIAL_16 + +/*----------------- + * BITMAPS + *----------------*/ + +/*Store the image of the glyphs*/ +static LV_ATTRIBUTE_LARGE_CONST const uint8_t glyph_bitmap[] = { + /* U+0020 " " */ + + /* U+0021 "!" */ + 0xaf, 0x1a, 0xf1, 0xaf, 0x19, 0xf0, 0x8f, 0x7, + 0xe0, 0x6d, 0x5, 0xc0, 0x4b, 0x0, 0x10, 0x6b, + 0x9, 0xf0, + + /* U+0022 "\"" */ + 0x4f, 0x5a, 0xf4, 0xf5, 0xaf, 0x2f, 0x49, 0xd0, + 0xf1, 0x6b, 0x4, 0x1, 0x20, + + /* U+0023 "#" */ + 0x0, 0xd, 0x40, 0x3f, 0x0, 0x1, 0xf1, 0x7, + 0xb0, 0x0, 0x5d, 0x0, 0xa7, 0xc, 0xff, 0xff, + 0xff, 0xfb, 0x23, 0xc8, 0x35, 0xf4, 0x20, 0xe, + 0x30, 0x4d, 0x0, 0x2, 0xf0, 0x8, 0xa0, 0xc, + 0xff, 0xff, 0xff, 0xfb, 0x2a, 0xb3, 0x3f, 0x63, + 0x20, 0xb7, 0x1, 0xf1, 0x0, 0xe, 0x40, 0x4e, + 0x0, 0x1, 0xf1, 0x7, 0xb0, 0x0, + + /* U+0024 "$" */ + 0x0, 0x0, 0x60, 0x0, 0x0, 0x4, 0xaf, 0x93, + 0x0, 0x6, 0xfa, 0xec, 0xf3, 0x0, 0xf8, 0xd, + 0xd, 0xb0, 0x1f, 0x40, 0xd0, 0x33, 0x0, 0xf8, + 0xd, 0x0, 0x0, 0x8, 0xfa, 0xd0, 0x0, 0x0, + 0x6, 0xdf, 0xf8, 0x0, 0x0, 0x0, 0xd8, 0xfa, + 0x0, 0x0, 0xd, 0x7, 0xf0, 0x3c, 0x10, 0xd0, + 0x4f, 0x22, 0xf6, 0xd, 0x8, 0xf0, 0xb, 0xf6, + 0xd7, 0xf8, 0x0, 0x9, 0xef, 0xe8, 0x0, 0x0, + 0x0, 0xd0, 0x0, 0x0, 0x0, 0x6, 0x0, 0x0, + + /* U+0025 "%" */ + 0x3, 0xcf, 0xb1, 0x0, 0x9, 0x90, 0x0, 0xd, + 0x81, 0xaa, 0x0, 0x1e, 0x10, 0x0, 0xf, 0x30, + 0x6d, 0x0, 0x98, 0x0, 0x0, 0xd, 0x60, 0xaa, + 0x2, 0xe1, 0x0, 0x0, 0x4, 0xef, 0xd2, 0xa, + 0x70, 0x0, 0x0, 0x0, 0x1, 0x0, 0x3e, 0x6, + 0xdb, 0x20, 0x0, 0x0, 0x0, 0xb7, 0x3f, 0x37, + 0xd0, 0x0, 0x0, 0x3, 0xe0, 0x8b, 0x0, 0xf2, + 0x0, 0x0, 0xc, 0x60, 0x99, 0x0, 0xf3, 0x0, + 0x0, 0x4d, 0x0, 0x8a, 0x0, 0xf2, 0x0, 0x0, + 0xc5, 0x0, 0x3e, 0x27, 0xd0, 0x0, 0x5, 0xd0, + 0x0, 0x7, 0xed, 0x30, + + /* U+0026 "&" */ + 0x0, 0x9, 0xee, 0x80, 0x0, 0x0, 0x8, 0xe5, + 0x7f, 0x50, 0x0, 0x0, 0xda, 0x0, 0xd9, 0x0, + 0x0, 0xa, 0xe0, 0x2f, 0x50, 0x0, 0x0, 0x2f, + 0xbe, 0x90, 0x0, 0x0, 0x4, 0xef, 0xb0, 0x0, + 0x0, 0x6, 0xf8, 0x8f, 0x60, 0x83, 0x1, 0xf9, + 0x0, 0xbf, 0x8f, 0x40, 0x4f, 0x40, 0x0, 0xdf, + 0xd0, 0x2, 0xf8, 0x0, 0x8, 0xfc, 0x0, 0xa, + 0xf8, 0x5a, 0xfa, 0xfc, 0x10, 0x9, 0xef, 0xc5, + 0x5, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0027 "'" */ + 0x4f, 0x54, 0xf5, 0x3f, 0x40, 0xf1, 0x4, 0x0, + + /* U+0028 "(" */ + 0x0, 0x9, 0x70, 0x3, 0xe0, 0x0, 0xc7, 0x0, + 0x3f, 0x10, 0x8, 0xd0, 0x0, 0xd9, 0x0, 0xf, + 0x70, 0x0, 0xf7, 0x0, 0xf, 0x70, 0x0, 0xd9, + 0x0, 0x8, 0xd0, 0x0, 0x3f, 0x10, 0x0, 0xc7, + 0x0, 0x4, 0xe0, 0x0, 0x9, 0x70, + + /* U+0029 ")" */ + 0x2d, 0x0, 0x0, 0x99, 0x0, 0x2, 0xf1, 0x0, + 0xc, 0x80, 0x0, 0x7e, 0x0, 0x4, 0xf2, 0x0, + 0x2f, 0x40, 0x1, 0xf5, 0x0, 0x2f, 0x40, 0x4, + 0xf2, 0x0, 0x7d, 0x0, 0xc, 0x80, 0x2, 0xf1, + 0x0, 0x99, 0x0, 0x2d, 0x0, 0x0, + + /* U+002A "*" */ + 0x0, 0x6a, 0x0, 0x27, 0x69, 0x54, 0x3a, 0xef, + 0xb5, 0x2, 0xed, 0x40, 0x9, 0x74, 0xc0, 0x0, + 0x0, 0x0, + + /* U+002B "+" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x50, + 0x0, 0x0, 0x0, 0xf5, 0x0, 0x0, 0x11, 0x1f, + 0x61, 0x10, 0x1f, 0xff, 0xff, 0xff, 0x70, 0x44, + 0x4f, 0x84, 0x42, 0x0, 0x0, 0xf5, 0x0, 0x0, + 0x0, 0xf, 0x50, 0x0, 0x0, 0x0, 0xf5, 0x0, + 0x0, + + /* U+002C "," */ + 0x6b, 0x9f, 0xd, 0x69, 0x20, + + /* U+002D "-" */ + 0x38, 0x88, 0x67, 0xff, 0xfd, + + /* U+002E "." */ + 0x6b, 0x9, 0xf0, + + /* U+002F "/" */ + 0x0, 0xd, 0x50, 0x1, 0xf0, 0x0, 0x5c, 0x0, + 0xa, 0x70, 0x0, 0xe3, 0x0, 0x3e, 0x0, 0x7, + 0xa0, 0x0, 0xc6, 0x0, 0xf, 0x10, 0x4, 0xd0, + 0x0, 0x98, 0x0, 0xd, 0x40, 0x0, + + /* U+0030 "0" */ + 0x0, 0x6d, 0xfd, 0x40, 0x0, 0x5f, 0x84, 0x9f, + 0x30, 0xd, 0xa0, 0x0, 0xca, 0x1, 0xf5, 0x0, + 0x7, 0xf0, 0x3f, 0x30, 0x0, 0x5f, 0x14, 0xf2, + 0x0, 0x4, 0xf2, 0x4f, 0x20, 0x0, 0x4f, 0x23, + 0xf3, 0x0, 0x5, 0xf1, 0x1f, 0x50, 0x0, 0x7f, + 0x0, 0xda, 0x0, 0xc, 0xa0, 0x5, 0xf8, 0x49, + 0xf3, 0x0, 0x6, 0xdf, 0xd4, 0x0, + + /* U+0031 "1" */ + 0x0, 0x3, 0xf0, 0x2, 0xef, 0x6, 0xfe, 0xf3, + 0xf8, 0x6f, 0x11, 0x6, 0xf0, 0x0, 0x6f, 0x0, + 0x6, 0xf0, 0x0, 0x6f, 0x0, 0x6, 0xf0, 0x0, + 0x6f, 0x0, 0x6, 0xf0, 0x0, 0x6f, + + /* U+0032 "2" */ + 0x0, 0x7d, 0xfd, 0x60, 0x0, 0x8f, 0x74, 0x8f, + 0x70, 0xf, 0x70, 0x0, 0x9e, 0x1, 0x82, 0x0, + 0x7, 0xf0, 0x0, 0x0, 0x0, 0xbd, 0x0, 0x0, + 0x0, 0x6f, 0x50, 0x0, 0x0, 0x5f, 0x80, 0x0, + 0x0, 0x7f, 0x80, 0x0, 0x0, 0x8f, 0x60, 0x0, + 0x0, 0x7f, 0x50, 0x0, 0x0, 0x2f, 0xc7, 0x77, + 0x77, 0x7, 0xff, 0xff, 0xff, 0xf1, + + /* U+0033 "3" */ + 0x0, 0x7d, 0xfc, 0x30, 0x0, 0x8f, 0x74, 0xaf, + 0x20, 0xf, 0x80, 0x0, 0xe8, 0x0, 0x31, 0x0, + 0xe, 0x90, 0x0, 0x0, 0x18, 0xf3, 0x0, 0x0, + 0x6f, 0xf8, 0x0, 0x0, 0x2, 0x37, 0xf9, 0x0, + 0x0, 0x0, 0x8, 0xf1, 0x16, 0x10, 0x0, 0x5f, + 0x21, 0xf7, 0x0, 0x9, 0xf0, 0x9, 0xf7, 0x49, + 0xf7, 0x0, 0x7, 0xdf, 0xd6, 0x0, + + /* U+0034 "4" */ + 0x0, 0x0, 0xd, 0x90, 0x0, 0x0, 0x8, 0xf9, + 0x0, 0x0, 0x3, 0xfe, 0x90, 0x0, 0x0, 0xd7, + 0xc9, 0x0, 0x0, 0x8d, 0xc, 0x90, 0x0, 0x3f, + 0x30, 0xc9, 0x0, 0xd, 0x80, 0xc, 0x90, 0x7, + 0xe2, 0x11, 0xda, 0x10, 0xcf, 0xff, 0xff, 0xff, + 0x23, 0x44, 0x44, 0xdb, 0x40, 0x0, 0x0, 0xc, + 0x90, 0x0, 0x0, 0x0, 0xc9, 0x0, + + /* U+0035 "5" */ + 0x0, 0xff, 0xff, 0xfc, 0x0, 0x3f, 0x76, 0x66, + 0x50, 0x6, 0xf0, 0x0, 0x0, 0x0, 0x9c, 0x0, + 0x0, 0x0, 0xb, 0xcc, 0xff, 0x80, 0x0, 0xee, + 0x64, 0x9f, 0x90, 0x4, 0x20, 0x0, 0x9f, 0x10, + 0x0, 0x0, 0x4, 0xf4, 0x16, 0x10, 0x0, 0x4f, + 0x31, 0xf7, 0x0, 0xa, 0xe0, 0x9, 0xf7, 0x49, + 0xf6, 0x0, 0x7, 0xdf, 0xd6, 0x0, + + /* U+0036 "6" */ + 0x0, 0x3c, 0xfe, 0x80, 0x0, 0x3f, 0x94, 0x6f, + 0x80, 0xb, 0xb0, 0x0, 0x7c, 0x0, 0xf5, 0x0, + 0x0, 0x0, 0x3f, 0x4b, 0xff, 0x90, 0x4, 0xfe, + 0x94, 0x8f, 0x80, 0x5f, 0xa0, 0x0, 0x8f, 0x4, + 0xf5, 0x0, 0x4, 0xf2, 0x2f, 0x50, 0x0, 0x4f, + 0x20, 0xdb, 0x0, 0x9, 0xe0, 0x5, 0xf9, 0x48, + 0xf6, 0x0, 0x4, 0xcf, 0xe7, 0x0, + + /* U+0037 "7" */ + 0x3f, 0xff, 0xff, 0xff, 0x31, 0x66, 0x66, 0x6e, + 0xd0, 0x0, 0x0, 0x5, 0xf3, 0x0, 0x0, 0x1, + 0xe9, 0x0, 0x0, 0x0, 0x8f, 0x10, 0x0, 0x0, + 0xe, 0x80, 0x0, 0x0, 0x6, 0xf1, 0x0, 0x0, + 0x0, 0xcb, 0x0, 0x0, 0x0, 0x1f, 0x60, 0x0, + 0x0, 0x4, 0xf3, 0x0, 0x0, 0x0, 0x7f, 0x0, + 0x0, 0x0, 0x9, 0xe0, 0x0, 0x0, + + /* U+0038 "8" */ + 0x0, 0x6d, 0xfc, 0x40, 0x0, 0x6f, 0x84, 0x9f, + 0x40, 0xc, 0xb0, 0x0, 0xda, 0x0, 0xca, 0x0, + 0xc, 0xb0, 0x6, 0xf4, 0x6, 0xf6, 0x0, 0xa, + 0xff, 0xf8, 0x0, 0xb, 0xf6, 0x47, 0xf7, 0x2, + 0xf6, 0x0, 0x7, 0xf1, 0x4f, 0x20, 0x0, 0x4f, + 0x32, 0xf6, 0x0, 0x7, 0xf1, 0xa, 0xf7, 0x47, + 0xf9, 0x0, 0x7, 0xdf, 0xd6, 0x0, + + /* U+0039 "9" */ + 0x0, 0x8e, 0xfc, 0x30, 0x0, 0x9f, 0x84, 0x8f, + 0x30, 0x1f, 0x70, 0x0, 0x9c, 0x4, 0xf3, 0x0, + 0x5, 0xf0, 0x2f, 0x50, 0x0, 0x8f, 0x20, 0xce, + 0x41, 0x5e, 0xf3, 0x2, 0xcf, 0xfd, 0x6f, 0x30, + 0x0, 0x23, 0x4, 0xf1, 0x5, 0x10, 0x0, 0x8f, + 0x0, 0xe8, 0x0, 0xe, 0xa0, 0x7, 0xf6, 0x4b, + 0xf2, 0x0, 0x8, 0xef, 0xb2, 0x0, + + /* U+003A ":" */ + 0x9f, 0x6, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xb0, 0x9f, 0x0, + + /* U+003B ";" */ + 0x9f, 0x6b, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6b, + 0x9f, 0xd, 0x69, 0x20, + + /* U+003C "<" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xa7, 0x0, 0x0, 0x5c, 0xfc, 0x30, 0x6, 0xdf, + 0xa3, 0x0, 0x1e, 0xe8, 0x10, 0x0, 0x1, 0xee, + 0x81, 0x0, 0x0, 0x0, 0x6d, 0xfa, 0x30, 0x0, + 0x0, 0x5, 0xcf, 0xc3, 0x0, 0x0, 0x0, 0x3b, + 0x70, 0x0, 0x0, 0x0, 0x0, + + /* U+003D "=" */ + 0x1f, 0xff, 0xff, 0xff, 0x70, 0x66, 0x66, 0x66, + 0x62, 0x0, 0x0, 0x0, 0x0, 0x0, 0x11, 0x11, + 0x11, 0x10, 0x1f, 0xff, 0xff, 0xff, 0x70, 0x44, + 0x44, 0x44, 0x42, + + /* U+003E ">" */ + 0x0, 0x0, 0x0, 0x0, 0x1, 0xd6, 0x0, 0x0, + 0x0, 0xa, 0xfe, 0x71, 0x0, 0x0, 0x1, 0x8e, + 0xf9, 0x20, 0x0, 0x0, 0x6, 0xdf, 0x60, 0x0, + 0x0, 0x6d, 0xf5, 0x0, 0x18, 0xef, 0x92, 0x0, + 0xaf, 0xe7, 0x10, 0x0, 0x1d, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+003F "?" */ + 0x0, 0x7d, 0xfd, 0x60, 0x0, 0x8f, 0x74, 0x8f, + 0x90, 0xf, 0x80, 0x0, 0x9f, 0x1, 0x82, 0x0, + 0x5, 0xf1, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x0, + 0x0, 0xbe, 0x20, 0x0, 0x0, 0xae, 0x20, 0x0, + 0x0, 0x2f, 0x50, 0x0, 0x0, 0x4, 0xf1, 0x0, + 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x4, 0xb2, + 0x0, 0x0, 0x0, 0x5f, 0x30, 0x0, + + /* U+0040 "@" */ + 0x0, 0x0, 0x6, 0xbe, 0xfe, 0xc7, 0x0, 0x0, + 0x0, 0x3, 0xee, 0x85, 0x34, 0x8e, 0xe3, 0x0, + 0x0, 0x2f, 0x90, 0x0, 0x0, 0x0, 0x9e, 0x10, + 0x0, 0xd9, 0x0, 0x9e, 0xe6, 0x8d, 0xa, 0xa0, + 0x5, 0xe0, 0xb, 0xe5, 0x5e, 0xea, 0x2, 0xf1, + 0xb, 0x70, 0x6f, 0x30, 0x5, 0xf7, 0x0, 0xe4, + 0xf, 0x30, 0xcb, 0x0, 0x2, 0xf4, 0x0, 0xd4, + 0xf, 0x10, 0xf7, 0x0, 0x4, 0xf1, 0x0, 0xf2, + 0xf, 0x21, 0xf5, 0x0, 0x9, 0xe0, 0x6, 0xe0, + 0xf, 0x40, 0xe9, 0x0, 0x3f, 0xb0, 0x2e, 0x50, + 0xa, 0xa0, 0x8f, 0x87, 0xef, 0xd7, 0xe9, 0x0, + 0x3, 0xf4, 0xa, 0xfd, 0x48, 0xfd, 0x60, 0x21, + 0x0, 0x8e, 0x50, 0x0, 0x0, 0x0, 0x8, 0xf3, + 0x0, 0x7, 0xfd, 0x85, 0x44, 0x59, 0xed, 0x30, + 0x0, 0x0, 0x18, 0xce, 0xfe, 0xda, 0x40, 0x0, + + /* U+0041 "A" */ + 0x0, 0x0, 0xc, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xd9, 0x0, 0x0, 0x0, 0x0, 0x8d, 0x6f, + 0x0, 0x0, 0x0, 0x0, 0xe8, 0x1f, 0x60, 0x0, + 0x0, 0x4, 0xf3, 0xb, 0xc0, 0x0, 0x0, 0xa, + 0xd0, 0x5, 0xf2, 0x0, 0x0, 0xf, 0x81, 0x11, + 0xf9, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0xbc, 0x44, 0x44, 0x6f, 0x50, 0x1, 0xf7, + 0x0, 0x0, 0xe, 0xb0, 0x7, 0xf1, 0x0, 0x0, + 0x8, 0xf2, 0xd, 0xc0, 0x0, 0x0, 0x3, 0xf8, + + /* U+0042 "B" */ + 0xdf, 0xff, 0xfd, 0x91, 0xd, 0xd7, 0x77, 0x9f, + 0xc0, 0xdb, 0x0, 0x0, 0x6f, 0x2d, 0xb0, 0x0, + 0x4, 0xf3, 0xdb, 0x22, 0x24, 0xcc, 0xd, 0xff, + 0xff, 0xff, 0x30, 0xdc, 0x55, 0x57, 0xdf, 0x3d, + 0xb0, 0x0, 0x0, 0xea, 0xdb, 0x0, 0x0, 0xc, + 0xcd, 0xb0, 0x0, 0x1, 0xfa, 0xdd, 0x77, 0x78, + 0xef, 0x2d, 0xff, 0xff, 0xeb, 0x40, + + /* U+0043 "C" */ + 0x0, 0x4, 0xbe, 0xfc, 0x60, 0x0, 0x8, 0xfc, + 0x76, 0xaf, 0xa0, 0x5, 0xf8, 0x0, 0x0, 0x6f, + 0x50, 0xce, 0x0, 0x0, 0x0, 0x95, 0xf, 0x90, + 0x0, 0x0, 0x0, 0x2, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0x60, 0x0, 0x0, 0x0, 0x0, 0xf8, + 0x0, 0x0, 0x0, 0x20, 0xc, 0xd0, 0x0, 0x0, + 0xd, 0xc0, 0x5f, 0x70, 0x0, 0x7, 0xf6, 0x0, + 0x9f, 0xb6, 0x7b, 0xfa, 0x0, 0x0, 0x6c, 0xff, + 0xc6, 0x0, + + /* U+0044 "D" */ + 0xbf, 0xff, 0xfe, 0xb4, 0x0, 0xbe, 0x77, 0x78, + 0xdf, 0x50, 0xbc, 0x0, 0x0, 0xc, 0xf0, 0xbc, + 0x0, 0x0, 0x4, 0xf6, 0xbc, 0x0, 0x0, 0x0, + 0xf9, 0xbc, 0x0, 0x0, 0x0, 0xdb, 0xbc, 0x0, + 0x0, 0x0, 0xea, 0xbc, 0x0, 0x0, 0x0, 0xf9, + 0xbc, 0x0, 0x0, 0x4, 0xf5, 0xbc, 0x0, 0x0, + 0xc, 0xe0, 0xbe, 0x77, 0x79, 0xef, 0x40, 0xbf, + 0xff, 0xfe, 0xa3, 0x0, + + /* U+0045 "E" */ + 0xbf, 0xff, 0xff, 0xff, 0x8b, 0xe7, 0x77, 0x77, + 0x73, 0xbc, 0x0, 0x0, 0x0, 0xb, 0xc0, 0x0, + 0x0, 0x0, 0xbc, 0x22, 0x22, 0x22, 0xb, 0xff, + 0xff, 0xff, 0xf2, 0xbd, 0x55, 0x55, 0x55, 0xb, + 0xc0, 0x0, 0x0, 0x0, 0xbc, 0x0, 0x0, 0x0, + 0xb, 0xc0, 0x0, 0x0, 0x0, 0xbe, 0x77, 0x77, + 0x77, 0x5b, 0xff, 0xff, 0xff, 0xfd, + + /* U+0046 "F" */ + 0xbf, 0xff, 0xff, 0xff, 0xb, 0xe7, 0x77, 0x77, + 0x70, 0xbc, 0x0, 0x0, 0x0, 0xb, 0xc0, 0x0, + 0x0, 0x0, 0xbd, 0x22, 0x22, 0x20, 0xb, 0xff, + 0xff, 0xff, 0x20, 0xbd, 0x55, 0x55, 0x50, 0xb, + 0xc0, 0x0, 0x0, 0x0, 0xbc, 0x0, 0x0, 0x0, + 0xb, 0xc0, 0x0, 0x0, 0x0, 0xbc, 0x0, 0x0, + 0x0, 0xb, 0xc0, 0x0, 0x0, 0x0, + + /* U+0047 "G" */ + 0x0, 0x3, 0xae, 0xfe, 0xa3, 0x0, 0x0, 0x6f, + 0xd7, 0x68, 0xdf, 0x40, 0x3, 0xf9, 0x0, 0x0, + 0xc, 0xd0, 0xb, 0xe0, 0x0, 0x0, 0x3, 0xa1, + 0xf, 0x90, 0x0, 0x0, 0x0, 0x0, 0x2f, 0x60, + 0x0, 0x2, 0x22, 0x20, 0x2f, 0x60, 0x0, 0x6f, + 0xff, 0xf6, 0xf, 0x90, 0x0, 0x25, 0x55, 0xf6, + 0xb, 0xe0, 0x0, 0x0, 0x1, 0xf6, 0x4, 0xfa, + 0x0, 0x0, 0x5, 0xf6, 0x0, 0x6f, 0xe9, 0x78, + 0xdf, 0xc1, 0x0, 0x3, 0xae, 0xfe, 0xb5, 0x0, + + /* U+0048 "H" */ + 0xbc, 0x0, 0x0, 0x4, 0xf4, 0xbc, 0x0, 0x0, + 0x4, 0xf4, 0xbc, 0x0, 0x0, 0x4, 0xf4, 0xbc, + 0x0, 0x0, 0x4, 0xf4, 0xbd, 0x22, 0x22, 0x25, + 0xf4, 0xbf, 0xff, 0xff, 0xff, 0xf4, 0xbd, 0x55, + 0x55, 0x57, 0xf4, 0xbc, 0x0, 0x0, 0x4, 0xf4, + 0xbc, 0x0, 0x0, 0x4, 0xf4, 0xbc, 0x0, 0x0, + 0x4, 0xf4, 0xbc, 0x0, 0x0, 0x4, 0xf4, 0xbc, + 0x0, 0x0, 0x4, 0xf4, + + /* U+0049 "I" */ + 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, + 0x8f, 0x8f, 0x8f, 0x8f, + + /* U+004A "J" */ + 0x0, 0x0, 0xc, 0xc0, 0x0, 0x0, 0xcc, 0x0, + 0x0, 0xc, 0xc0, 0x0, 0x0, 0xcc, 0x0, 0x0, + 0xc, 0xc0, 0x0, 0x0, 0xcc, 0x0, 0x0, 0xc, + 0xc0, 0x0, 0x0, 0xcc, 0x49, 0x0, 0xc, 0xb6, + 0xf1, 0x0, 0xea, 0x1f, 0xc7, 0xbf, 0x40, 0x4d, + 0xfd, 0x60, + + /* U+004B "K" */ + 0xdb, 0x0, 0x0, 0x2e, 0xd1, 0xdb, 0x0, 0x2, + 0xed, 0x10, 0xdb, 0x0, 0x1e, 0xd1, 0x0, 0xdb, + 0x1, 0xdd, 0x10, 0x0, 0xdb, 0x1d, 0xe1, 0x0, + 0x0, 0xdc, 0xcf, 0xf2, 0x0, 0x0, 0xdf, 0xe3, + 0xec, 0x0, 0x0, 0xde, 0x20, 0x5f, 0x70, 0x0, + 0xdb, 0x0, 0xb, 0xf3, 0x0, 0xdb, 0x0, 0x1, + 0xed, 0x0, 0xdb, 0x0, 0x0, 0x5f, 0x90, 0xdb, + 0x0, 0x0, 0xa, 0xf4, + + /* U+004C "L" */ + 0xcb, 0x0, 0x0, 0x0, 0xcb, 0x0, 0x0, 0x0, + 0xcb, 0x0, 0x0, 0x0, 0xcb, 0x0, 0x0, 0x0, + 0xcb, 0x0, 0x0, 0x0, 0xcb, 0x0, 0x0, 0x0, + 0xcb, 0x0, 0x0, 0x0, 0xcb, 0x0, 0x0, 0x0, + 0xcb, 0x0, 0x0, 0x0, 0xcb, 0x0, 0x0, 0x0, + 0xcd, 0x77, 0x77, 0x72, 0xcf, 0xff, 0xff, 0xf5, + + /* U+004D "M" */ + 0xcf, 0xa0, 0x0, 0x0, 0x1f, 0xf2, 0xcf, 0xf0, + 0x0, 0x0, 0x6f, 0xf2, 0xcc, 0xf4, 0x0, 0x0, + 0xbd, 0xf2, 0xca, 0xc9, 0x0, 0x1, 0xf7, 0xf2, + 0xca, 0x7e, 0x0, 0x6, 0xd5, 0xf2, 0xca, 0x2f, + 0x30, 0xb, 0x75, 0xf2, 0xca, 0xc, 0x90, 0xf, + 0x25, 0xf2, 0xca, 0x7, 0xe0, 0x5d, 0x5, 0xf2, + 0xca, 0x2, 0xf3, 0xb8, 0x5, 0xf2, 0xca, 0x0, + 0xd8, 0xf2, 0x5, 0xf2, 0xca, 0x0, 0x8f, 0xd0, + 0x5, 0xf2, 0xca, 0x0, 0x2f, 0x80, 0x5, 0xf2, + + /* U+004E "N" */ + 0xbf, 0x20, 0x0, 0x2, 0xf4, 0xbf, 0xc0, 0x0, + 0x2, 0xf4, 0xbf, 0xf6, 0x0, 0x2, 0xf4, 0xbb, + 0xaf, 0x10, 0x2, 0xf4, 0xbb, 0x1f, 0xb0, 0x2, + 0xf4, 0xbb, 0x6, 0xf5, 0x2, 0xf4, 0xbb, 0x0, + 0xce, 0x12, 0xf4, 0xbb, 0x0, 0x2f, 0x92, 0xf4, + 0xbb, 0x0, 0x7, 0xf6, 0xf4, 0xbb, 0x0, 0x0, + 0xdf, 0xf4, 0xbb, 0x0, 0x0, 0x3f, 0xf4, 0xbb, + 0x0, 0x0, 0x9, 0xf4, + + /* U+004F "O" */ + 0x0, 0x4, 0xbe, 0xfd, 0x80, 0x0, 0x0, 0x8f, + 0xc7, 0x69, 0xfd, 0x10, 0x5, 0xf8, 0x0, 0x0, + 0x2e, 0xc0, 0xd, 0xc0, 0x0, 0x0, 0x6, 0xf4, + 0x1f, 0x70, 0x0, 0x0, 0x0, 0xf8, 0x3f, 0x50, + 0x0, 0x0, 0x0, 0xea, 0x3f, 0x50, 0x0, 0x0, + 0x0, 0xea, 0x1f, 0x70, 0x0, 0x0, 0x0, 0xf8, + 0xc, 0xd0, 0x0, 0x0, 0x6, 0xf4, 0x4, 0xf8, + 0x0, 0x0, 0x2e, 0xc0, 0x0, 0x7f, 0xc7, 0x69, + 0xfd, 0x10, 0x0, 0x4, 0xbe, 0xfd, 0x80, 0x0, + + /* U+0050 "P" */ + 0xcf, 0xff, 0xff, 0xc6, 0xc, 0xd7, 0x77, 0x7c, + 0xf6, 0xcc, 0x0, 0x0, 0xd, 0xdc, 0xc0, 0x0, + 0x0, 0x9f, 0xcc, 0x0, 0x0, 0xc, 0xdc, 0xc2, + 0x22, 0x39, 0xf7, 0xcf, 0xff, 0xff, 0xfa, 0xc, + 0xd5, 0x54, 0x41, 0x0, 0xcc, 0x0, 0x0, 0x0, + 0xc, 0xc0, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x0, + 0x0, 0xc, 0xc0, 0x0, 0x0, 0x0, + + /* U+0051 "Q" */ + 0x0, 0x4, 0xbe, 0xfd, 0x70, 0x0, 0x0, 0x8f, + 0xc7, 0x69, 0xfd, 0x10, 0x5, 0xf8, 0x0, 0x0, + 0x2e, 0xb0, 0xc, 0xc0, 0x0, 0x0, 0x6, 0xf3, + 0x1f, 0x70, 0x0, 0x0, 0x0, 0xf8, 0x3f, 0x50, + 0x0, 0x0, 0x0, 0xea, 0x3f, 0x50, 0x0, 0x0, + 0x0, 0xea, 0x1f, 0x70, 0x0, 0x0, 0x0, 0xf8, + 0xc, 0xd0, 0x0, 0x32, 0x5, 0xf4, 0x4, 0xf8, + 0x0, 0x7f, 0x9e, 0xc0, 0x0, 0x8f, 0xc7, 0x6b, + 0xff, 0x40, 0x0, 0x4, 0xbf, 0xfd, 0x79, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x46, + + /* U+0052 "R" */ + 0xbf, 0xff, 0xff, 0xeb, 0x20, 0xb, 0xd5, 0x55, + 0x58, 0xee, 0x0, 0xbc, 0x0, 0x0, 0x4, 0xf5, + 0xb, 0xc0, 0x0, 0x0, 0x3f, 0x50, 0xbd, 0x11, + 0x12, 0x4d, 0xe1, 0xb, 0xff, 0xff, 0xff, 0xc3, + 0x0, 0xbd, 0x44, 0x7e, 0xb0, 0x0, 0xb, 0xc0, + 0x0, 0x3f, 0xb0, 0x0, 0xbc, 0x0, 0x0, 0x8f, + 0x60, 0xb, 0xc0, 0x0, 0x0, 0xee, 0x0, 0xbc, + 0x0, 0x0, 0x6, 0xf8, 0xb, 0xc0, 0x0, 0x0, + 0xc, 0xf1, + + /* U+0053 "S" */ + 0x0, 0x3b, 0xef, 0xd7, 0x0, 0x4, 0xfd, 0x87, + 0xaf, 0xc0, 0xb, 0xd0, 0x0, 0x5, 0xf4, 0xc, + 0xb0, 0x0, 0x0, 0x93, 0x7, 0xf9, 0x30, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xb6, 0x0, 0x0, 0x0, + 0x48, 0xcf, 0xd1, 0x0, 0x0, 0x0, 0x3, 0xf9, + 0x3f, 0x50, 0x0, 0x0, 0xac, 0xf, 0xc0, 0x0, + 0x1, 0xea, 0x5, 0xfe, 0x97, 0x8e, 0xf3, 0x0, + 0x4b, 0xef, 0xea, 0x20, + + /* U+0054 "T" */ + 0xaf, 0xff, 0xff, 0xff, 0xf6, 0x47, 0x77, 0xec, + 0x77, 0x72, 0x0, 0x0, 0xea, 0x0, 0x0, 0x0, + 0x0, 0xea, 0x0, 0x0, 0x0, 0x0, 0xea, 0x0, + 0x0, 0x0, 0x0, 0xea, 0x0, 0x0, 0x0, 0x0, + 0xea, 0x0, 0x0, 0x0, 0x0, 0xea, 0x0, 0x0, + 0x0, 0x0, 0xea, 0x0, 0x0, 0x0, 0x0, 0xea, + 0x0, 0x0, 0x0, 0x0, 0xea, 0x0, 0x0, 0x0, + 0x0, 0xea, 0x0, 0x0, + + /* U+0055 "U" */ + 0xbc, 0x0, 0x0, 0x3, 0xf4, 0xbc, 0x0, 0x0, + 0x3, 0xf4, 0xbc, 0x0, 0x0, 0x3, 0xf4, 0xbc, + 0x0, 0x0, 0x3, 0xf4, 0xbc, 0x0, 0x0, 0x3, + 0xf4, 0xbc, 0x0, 0x0, 0x3, 0xf4, 0xbc, 0x0, + 0x0, 0x3, 0xf4, 0xbd, 0x0, 0x0, 0x4, 0xf3, + 0x9f, 0x0, 0x0, 0x6, 0xf2, 0x5f, 0x50, 0x0, + 0xc, 0xe0, 0xd, 0xfa, 0x79, 0xdf, 0x50, 0x1, + 0x9e, 0xfe, 0xb4, 0x0, + + /* U+0056 "V" */ + 0xbe, 0x0, 0x0, 0x0, 0x2f, 0x55, 0xf3, 0x0, + 0x0, 0x8, 0xf0, 0xf, 0x90, 0x0, 0x0, 0xda, + 0x0, 0xae, 0x0, 0x0, 0x3f, 0x40, 0x4, 0xf4, + 0x0, 0x9, 0xd0, 0x0, 0xe, 0x90, 0x0, 0xe8, + 0x0, 0x0, 0x8e, 0x0, 0x4f, 0x20, 0x0, 0x2, + 0xf4, 0xa, 0xc0, 0x0, 0x0, 0xc, 0xa0, 0xf6, + 0x0, 0x0, 0x0, 0x6e, 0x5f, 0x0, 0x0, 0x0, + 0x1, 0xfd, 0xa0, 0x0, 0x0, 0x0, 0xa, 0xf4, + 0x0, 0x0, + + /* U+0057 "W" */ + 0xbd, 0x0, 0x0, 0x7f, 0x90, 0x0, 0xb, 0xc7, + 0xf0, 0x0, 0xc, 0xed, 0x0, 0x0, 0xf7, 0x3f, + 0x40, 0x0, 0xf7, 0xf2, 0x0, 0x3f, 0x30, 0xe7, + 0x0, 0x4f, 0xf, 0x60, 0x7, 0xf0, 0xb, 0xb0, + 0x9, 0xc0, 0xba, 0x0, 0xab, 0x0, 0x7e, 0x0, + 0xd7, 0x6, 0xf0, 0xe, 0x70, 0x3, 0xf2, 0x1f, + 0x30, 0x2f, 0x32, 0xf2, 0x0, 0xe, 0x65, 0xf0, + 0x0, 0xe7, 0x5e, 0x0, 0x0, 0xa9, 0x9a, 0x0, + 0xa, 0xa9, 0xa0, 0x0, 0x6, 0xcd, 0x60, 0x0, + 0x5d, 0xd6, 0x0, 0x0, 0x2f, 0xf2, 0x0, 0x1, + 0xff, 0x20, 0x0, 0x0, 0xee, 0x0, 0x0, 0xd, + 0xe0, 0x0, + + /* U+0058 "X" */ + 0x1f, 0xb0, 0x0, 0x0, 0xbd, 0x0, 0x6f, 0x60, + 0x0, 0x7f, 0x30, 0x0, 0xbf, 0x20, 0x3f, 0x70, + 0x0, 0x1, 0xec, 0xd, 0xc0, 0x0, 0x0, 0x5, + 0xfd, 0xe1, 0x0, 0x0, 0x0, 0xb, 0xf6, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xc0, 0x0, 0x0, 0x0, + 0xbe, 0x6f, 0x70, 0x0, 0x0, 0x7f, 0x40, 0xaf, + 0x30, 0x0, 0x2f, 0x90, 0x1, 0xed, 0x0, 0xd, + 0xd0, 0x0, 0x4, 0xf8, 0x9, 0xf3, 0x0, 0x0, + 0xa, 0xf3, + + /* U+0059 "Y" */ + 0xaf, 0x30, 0x0, 0x0, 0x8f, 0x31, 0xec, 0x0, + 0x0, 0x2f, 0x80, 0x5, 0xf7, 0x0, 0xc, 0xd0, + 0x0, 0xb, 0xf1, 0x6, 0xf3, 0x0, 0x0, 0x1f, + 0xa1, 0xe9, 0x0, 0x0, 0x0, 0x7f, 0xcd, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0x40, 0x0, 0x0, 0x0, + 0x8, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0x0, 0x0, 0x0, 0x0, 0x8, 0xf0, + 0x0, 0x0, + + /* U+005A "Z" */ + 0xf, 0xff, 0xff, 0xff, 0xf2, 0x7, 0x77, 0x77, + 0x7e, 0xf1, 0x0, 0x0, 0x0, 0x8f, 0x50, 0x0, + 0x0, 0x5, 0xf8, 0x0, 0x0, 0x0, 0x2f, 0xc0, + 0x0, 0x0, 0x0, 0xde, 0x10, 0x0, 0x0, 0xa, + 0xf4, 0x0, 0x0, 0x0, 0x6f, 0x70, 0x0, 0x0, + 0x3, 0xfa, 0x0, 0x0, 0x0, 0x1d, 0xd0, 0x0, + 0x0, 0x0, 0x9f, 0x97, 0x77, 0x77, 0x72, 0xbf, + 0xff, 0xff, 0xff, 0xf5, + + /* U+005B "[" */ + 0xff, 0xf2, 0xf9, 0x30, 0xf7, 0x0, 0xf7, 0x0, + 0xf7, 0x0, 0xf7, 0x0, 0xf7, 0x0, 0xf7, 0x0, + 0xf7, 0x0, 0xf7, 0x0, 0xf7, 0x0, 0xf7, 0x0, + 0xf7, 0x0, 0xf9, 0x30, 0xff, 0xf2, + + /* U+005C "\\" */ + 0xd4, 0x0, 0x9, 0x80, 0x0, 0x4d, 0x0, 0x0, + 0xf1, 0x0, 0xc, 0x60, 0x0, 0x7a, 0x0, 0x3, + 0xe0, 0x0, 0xe, 0x30, 0x0, 0xa7, 0x0, 0x5, + 0xc0, 0x0, 0x1f, 0x0, 0x0, 0xd5, + + /* U+005D "]" */ + 0xbf, 0xf6, 0x23, 0xf6, 0x0, 0xf6, 0x0, 0xf6, + 0x0, 0xf6, 0x0, 0xf6, 0x0, 0xf6, 0x0, 0xf6, + 0x0, 0xf6, 0x0, 0xf6, 0x0, 0xf6, 0x0, 0xf6, + 0x0, 0xf6, 0x23, 0xf6, 0xbf, 0xf6, + + /* U+005E "^" */ + 0x0, 0x7, 0x30, 0x0, 0x0, 0x3f, 0xb0, 0x0, + 0x0, 0xab, 0xf2, 0x0, 0x1, 0xf3, 0xb9, 0x0, + 0x8, 0xd0, 0x5f, 0x10, 0xe, 0x70, 0xe, 0x70, + 0x5f, 0x10, 0x8, 0xd0, + + /* U+005F "_" */ + 0x1f, 0xff, 0xff, 0xff, 0xff, 0x2, 0x22, 0x22, + 0x22, 0x22, + + /* U+0060 "`" */ + 0x5, 0x30, 0xa, 0xe0, 0x0, 0xd6, + + /* U+0061 "a" */ + 0x0, 0x8e, 0xfe, 0x90, 0x0, 0xae, 0x64, 0x7f, + 0x90, 0xb, 0x50, 0x0, 0xbc, 0x0, 0x0, 0x14, + 0x6d, 0xc0, 0x4, 0xdf, 0xfc, 0xdd, 0x2, 0xfa, + 0x20, 0xa, 0xd0, 0x5f, 0x20, 0x0, 0xed, 0x2, + 0xfa, 0x34, 0xbf, 0xd0, 0x5, 0xdf, 0xd9, 0x6f, + 0x10, + + /* U+0062 "b" */ + 0xe7, 0x0, 0x0, 0x0, 0xe7, 0x0, 0x0, 0x0, + 0xe7, 0x0, 0x0, 0x0, 0xe8, 0xaf, 0xe7, 0x0, + 0xef, 0xa4, 0x8f, 0x70, 0xed, 0x0, 0x9, 0xe0, + 0xe8, 0x0, 0x4, 0xf2, 0xe6, 0x0, 0x2, 0xf4, + 0xe6, 0x0, 0x4, 0xf2, 0xea, 0x0, 0x8, 0xe0, + 0xef, 0x61, 0x5f, 0x60, 0xe8, 0xbf, 0xd6, 0x0, + + /* U+0063 "c" */ + 0x0, 0x7e, 0xfc, 0x40, 0x9, 0xf8, 0x49, 0xf3, + 0x1f, 0x80, 0x0, 0xb7, 0x4f, 0x30, 0x0, 0x0, + 0x5f, 0x10, 0x0, 0x0, 0x3f, 0x20, 0x0, 0x33, + 0x1f, 0x70, 0x0, 0xca, 0x8, 0xf7, 0x49, 0xf3, + 0x0, 0x8e, 0xfc, 0x40, + + /* U+0064 "d" */ + 0x0, 0x0, 0x0, 0xac, 0x0, 0x0, 0x0, 0xac, + 0x0, 0x0, 0x0, 0xac, 0x0, 0x9e, 0xf9, 0xac, + 0x9, 0xf7, 0x5b, 0xfc, 0x1f, 0x70, 0x0, 0xec, + 0x4f, 0x20, 0x0, 0xac, 0x6f, 0x0, 0x0, 0x8c, + 0x4f, 0x20, 0x0, 0x9c, 0x1f, 0x70, 0x0, 0xec, + 0x8, 0xf7, 0x4b, 0xfc, 0x0, 0x8e, 0xfa, 0x9c, + + /* U+0065 "e" */ + 0x0, 0x7d, 0xfd, 0x50, 0x0, 0x7f, 0x84, 0x8f, + 0x50, 0xf, 0x90, 0x0, 0x9d, 0x4, 0xf4, 0x0, + 0x5, 0xf2, 0x5f, 0xff, 0xff, 0xff, 0x34, 0xf5, + 0x33, 0x33, 0x30, 0x1f, 0x70, 0x0, 0x5b, 0x0, + 0x8f, 0x84, 0x7f, 0xa0, 0x0, 0x7d, 0xfe, 0x80, + 0x0, + + /* U+0066 "f" */ + 0x2, 0xcf, 0xd0, 0x8f, 0x75, 0x9, 0xc0, 0xe, + 0xff, 0xf6, 0x2a, 0xc2, 0x0, 0xac, 0x0, 0xa, + 0xc0, 0x0, 0xac, 0x0, 0xa, 0xc0, 0x0, 0xac, + 0x0, 0xa, 0xc0, 0x0, 0xac, 0x0, + + /* U+0067 "g" */ + 0x0, 0x9e, 0xfa, 0x7d, 0x9, 0xf7, 0x4b, 0xfd, + 0x1f, 0x60, 0x0, 0xed, 0x5f, 0x10, 0x0, 0x9d, + 0x6f, 0x0, 0x0, 0x7d, 0x5f, 0x10, 0x0, 0x9d, + 0x1f, 0x60, 0x0, 0xdd, 0x9, 0xf7, 0x4b, 0xfd, + 0x0, 0x9e, 0xfa, 0xac, 0x5, 0x10, 0x0, 0xba, + 0xe, 0xb4, 0x49, 0xf4, 0x3, 0xbe, 0xfc, 0x40, + + /* U+0068 "h" */ + 0xe7, 0x0, 0x0, 0xe, 0x70, 0x0, 0x0, 0xe7, + 0x0, 0x0, 0xe, 0x89, 0xfe, 0x90, 0xef, 0xa5, + 0x8f, 0x8e, 0xc0, 0x0, 0xbc, 0xe8, 0x0, 0x9, + 0xde, 0x70, 0x0, 0x9d, 0xe7, 0x0, 0x9, 0xde, + 0x70, 0x0, 0x9d, 0xe7, 0x0, 0x9, 0xde, 0x70, + 0x0, 0x9d, + + /* U+0069 "i" */ + 0xe7, 0xa5, 0x0, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, + 0xe7, 0xe7, 0xe7, 0xe7, + + /* U+006A "j" */ + 0x0, 0xe7, 0x0, 0xa5, 0x0, 0x0, 0x0, 0xe7, + 0x0, 0xe7, 0x0, 0xe7, 0x0, 0xe7, 0x0, 0xe7, + 0x0, 0xe7, 0x0, 0xe7, 0x0, 0xe7, 0x0, 0xe7, + 0x0, 0xf7, 0x27, 0xf4, 0x8f, 0xb0, + + /* U+006B "k" */ + 0xf7, 0x0, 0x0, 0xf, 0x70, 0x0, 0x0, 0xf7, + 0x0, 0x0, 0xf, 0x70, 0xa, 0xf3, 0xf7, 0x9, + 0xf3, 0xf, 0x77, 0xf4, 0x0, 0xfc, 0xfa, 0x0, + 0xf, 0xfb, 0xf2, 0x0, 0xf8, 0xd, 0xc0, 0xf, + 0x70, 0x4f, 0x60, 0xf7, 0x0, 0xbe, 0x1f, 0x70, + 0x2, 0xfa, + + /* U+006C "l" */ + 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, + 0xf7, 0xf7, 0xf7, 0xf7, + + /* U+006D "m" */ + 0xf6, 0xbf, 0xe7, 0x2b, 0xfd, 0x50, 0xff, 0x62, + 0x9f, 0xe5, 0x2a, 0xf1, 0xfa, 0x0, 0x1f, 0x90, + 0x3, 0xf3, 0xf7, 0x0, 0xf, 0x60, 0x1, 0xf4, + 0xf7, 0x0, 0xf, 0x60, 0x1, 0xf4, 0xf7, 0x0, + 0xf, 0x60, 0x1, 0xf4, 0xf7, 0x0, 0xf, 0x60, + 0x1, 0xf4, 0xf7, 0x0, 0xf, 0x60, 0x1, 0xf4, + 0xf7, 0x0, 0xf, 0x60, 0x1, 0xf4, + + /* U+006E "n" */ + 0xe7, 0xaf, 0xe9, 0xe, 0xf7, 0x25, 0xf8, 0xeb, + 0x0, 0xb, 0xce, 0x80, 0x0, 0x9d, 0xe8, 0x0, + 0x9, 0xde, 0x80, 0x0, 0x9d, 0xe8, 0x0, 0x9, + 0xde, 0x80, 0x0, 0x9d, 0xe8, 0x0, 0x9, 0xd0, + + /* U+006F "o" */ + 0x0, 0x7d, 0xfd, 0x60, 0x0, 0x9f, 0x84, 0x8f, + 0x70, 0x2f, 0x70, 0x0, 0x9f, 0x5, 0xf2, 0x0, + 0x3, 0xf4, 0x6f, 0x0, 0x0, 0x2f, 0x55, 0xf2, + 0x0, 0x3, 0xf3, 0x2f, 0x70, 0x0, 0x9f, 0x0, + 0x9f, 0x84, 0x8f, 0x80, 0x0, 0x7e, 0xfd, 0x60, + 0x0, + + /* U+0070 "p" */ + 0xe7, 0xbf, 0xe8, 0x0, 0xef, 0x70, 0x4e, 0x70, + 0xec, 0x0, 0x7, 0xe0, 0xe7, 0x0, 0x3, 0xf2, + 0xe6, 0x0, 0x2, 0xf4, 0xe7, 0x0, 0x4, 0xf3, + 0xec, 0x0, 0x9, 0xe0, 0xef, 0xa4, 0x8f, 0x60, + 0xe8, 0xaf, 0xe6, 0x0, 0xe8, 0x0, 0x0, 0x0, + 0xe8, 0x0, 0x0, 0x0, 0xe8, 0x0, 0x0, 0x0, + + /* U+0071 "q" */ + 0x0, 0x9e, 0xf9, 0x8c, 0x9, 0xf6, 0x4b, 0xfc, + 0x1f, 0x60, 0x0, 0xec, 0x4f, 0x20, 0x0, 0x9c, + 0x5f, 0x10, 0x0, 0x8c, 0x4f, 0x20, 0x0, 0x9c, + 0x1f, 0x80, 0x0, 0xec, 0x7, 0xf7, 0x4b, 0xfc, + 0x0, 0x7e, 0xf9, 0xac, 0x0, 0x0, 0x0, 0xac, + 0x0, 0x0, 0x0, 0xac, 0x0, 0x0, 0x0, 0xac, + + /* U+0072 "r" */ + 0xf7, 0xdf, 0x5f, 0xf8, 0x71, 0xfb, 0x0, 0xf, + 0x80, 0x0, 0xf7, 0x0, 0xf, 0x70, 0x0, 0xf7, + 0x0, 0xf, 0x70, 0x0, 0xf7, 0x0, 0x0, + + /* U+0073 "s" */ + 0x3, 0xcf, 0xea, 0x10, 0xf, 0xa4, 0x5d, 0xc0, + 0x3f, 0x20, 0x3, 0x80, 0xe, 0xe9, 0x40, 0x0, + 0x2, 0xaf, 0xfe, 0x70, 0x0, 0x0, 0x4a, 0xf3, + 0x4e, 0x10, 0x1, 0xf5, 0x1e, 0xc4, 0x4b, 0xe1, + 0x3, 0xbe, 0xeb, 0x30, + + /* U+0074 "t" */ + 0x0, 0x0, 0x0, 0x49, 0x0, 0xb, 0xb0, 0x0, + 0xbb, 0x0, 0xbf, 0xff, 0x11, 0xbb, 0x20, 0xb, + 0xb0, 0x0, 0xbb, 0x0, 0xb, 0xb0, 0x0, 0xbb, + 0x0, 0xb, 0xb0, 0x0, 0xae, 0x60, 0x3, 0xef, + 0x30, + + /* U+0075 "u" */ + 0xf7, 0x0, 0xa, 0xcf, 0x70, 0x0, 0xac, 0xf7, + 0x0, 0xa, 0xcf, 0x70, 0x0, 0xac, 0xf7, 0x0, + 0xa, 0xce, 0x70, 0x0, 0xbc, 0xd9, 0x0, 0xe, + 0xca, 0xf7, 0x5b, 0xec, 0x1a, 0xfe, 0x87, 0xc0, + + /* U+0076 "v" */ + 0xad, 0x0, 0x0, 0xca, 0x4f, 0x20, 0x2, 0xf4, + 0xe, 0x80, 0x7, 0xe0, 0x9, 0xd0, 0xc, 0x90, + 0x3, 0xf2, 0x2f, 0x30, 0x0, 0xd8, 0x7e, 0x0, + 0x0, 0x8c, 0xc8, 0x0, 0x0, 0x2f, 0xf3, 0x0, + 0x0, 0xd, 0xd0, 0x0, + + /* U+0077 "w" */ + 0xca, 0x0, 0xf, 0xa0, 0x0, 0xf5, 0x8e, 0x0, + 0x4f, 0xe0, 0x5, 0xf0, 0x3f, 0x20, 0x8c, 0xf2, + 0x9, 0xb0, 0xe, 0x60, 0xc6, 0xe5, 0xd, 0x70, + 0xa, 0xa0, 0xf2, 0xb9, 0x2f, 0x20, 0x5, 0xe4, + 0xe0, 0x7d, 0x6e, 0x0, 0x1, 0xfb, 0xb0, 0x3f, + 0xc9, 0x0, 0x0, 0xcf, 0x70, 0xf, 0xf4, 0x0, + 0x0, 0x8f, 0x30, 0xb, 0xf0, 0x0, + + /* U+0078 "x" */ + 0x5f, 0x60, 0x5, 0xf5, 0xa, 0xe1, 0x1e, 0xa0, + 0x1, 0xe9, 0xae, 0x10, 0x0, 0x6f, 0xf4, 0x0, + 0x0, 0x1f, 0xf1, 0x0, 0x0, 0x9e, 0xe9, 0x0, + 0x4, 0xf5, 0x5f, 0x40, 0xd, 0xb0, 0xc, 0xd0, + 0x8f, 0x20, 0x2, 0xf9, + + /* U+0079 "y" */ + 0x8e, 0x0, 0x0, 0xba, 0x2f, 0x40, 0x1, 0xf4, + 0xd, 0xa0, 0x7, 0xe0, 0x7, 0xf0, 0xc, 0x90, + 0x1, 0xf5, 0x2f, 0x30, 0x0, 0xba, 0x7d, 0x0, + 0x0, 0x5f, 0xc7, 0x0, 0x0, 0xe, 0xf2, 0x0, + 0x0, 0xa, 0xc0, 0x0, 0x0, 0xe, 0x60, 0x0, + 0x17, 0xbe, 0x0, 0x0, 0xe, 0xe4, 0x0, 0x0, + + /* U+007A "z" */ + 0x6f, 0xff, 0xff, 0xf6, 0x13, 0x33, 0x3c, 0xe1, + 0x0, 0x0, 0x7f, 0x30, 0x0, 0x4, 0xf7, 0x0, + 0x0, 0x2e, 0xa0, 0x0, 0x0, 0xcd, 0x0, 0x0, + 0xa, 0xf2, 0x0, 0x0, 0x6f, 0x84, 0x44, 0x42, + 0xbf, 0xff, 0xff, 0xfa, + + /* U+007B "{" */ + 0x0, 0x4d, 0xf0, 0xc, 0xc5, 0x0, 0xe6, 0x0, + 0xe, 0x60, 0x0, 0xf5, 0x1, 0x8f, 0x10, 0x8f, + 0x30, 0x3, 0xbc, 0x0, 0x1, 0xf3, 0x0, 0xf, + 0x50, 0x0, 0xe6, 0x0, 0xe, 0x60, 0x0, 0xd6, + 0x0, 0xb, 0xd5, 0x0, 0x2d, 0xf0, + + /* U+007C "|" */ + 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, + 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, + + /* U+007D "}" */ + 0x9f, 0x80, 0x3, 0x8f, 0x20, 0x1, 0xf4, 0x0, + 0xf, 0x40, 0x0, 0xf6, 0x0, 0xa, 0xc2, 0x0, + 0xc, 0xe0, 0x6, 0xe5, 0x0, 0xd7, 0x0, 0xf, + 0x50, 0x0, 0xf4, 0x0, 0xf, 0x40, 0x1, 0xf3, + 0x3, 0x9f, 0x10, 0x9e, 0x60, 0x0, + + /* U+007E "~" */ + 0x3, 0x77, 0x30, 0x0, 0x33, 0xff, 0xff, 0xd9, + 0xca, 0x46, 0x12, 0x8d, 0xfc, 0x30, 0x0, 0x0, + 0x0, 0x0, + + /* U+00A0 " " */ + + /* U+00A3 "£" */ + 0x0, 0x4c, 0xfe, 0x80, 0x0, 0x5f, 0x94, 0x6f, + 0xa0, 0xb, 0xc0, 0x0, 0x6f, 0x0, 0xcc, 0x0, + 0x0, 0x0, 0x8, 0xf0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0x90, 0x0, 0x23, 0xf8, 0x31, 0x0, 0x0, + 0xf, 0x70, 0x0, 0x0, 0x2, 0xf2, 0x0, 0x0, + 0x0, 0xaa, 0x0, 0x0, 0x0, 0x8f, 0xef, 0xd9, + 0x7a, 0x26, 0xa5, 0x47, 0xcf, 0xd3, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+00A4 "¤" */ + 0x5, 0x0, 0x0, 0x5, 0x2, 0xfb, 0xef, 0xdb, + 0xf1, 0x7, 0xf9, 0x5a, 0xf5, 0x0, 0xab, 0x0, + 0xc, 0x90, 0xd, 0x70, 0x0, 0x9b, 0x0, 0xba, + 0x0, 0xb, 0xa0, 0x7, 0xf6, 0x27, 0xf5, 0x2, + 0xed, 0xff, 0xfd, 0xd1, 0x8, 0x1, 0x31, 0x18, + 0x0, + + /* U+00A5 "¥" */ + 0xbd, 0x0, 0x0, 0x1f, 0x93, 0xf5, 0x0, 0x8, + 0xf1, 0xa, 0xd0, 0x1, 0xf9, 0x0, 0x2f, 0x60, + 0x8f, 0x10, 0x0, 0x9e, 0x1f, 0x80, 0x0, 0x1, + 0xfd, 0xe1, 0x0, 0x7f, 0xff, 0xff, 0xff, 0x61, + 0x33, 0x6f, 0x53, 0x31, 0x7f, 0xff, 0xff, 0xff, + 0x61, 0x22, 0x5f, 0x52, 0x21, 0x0, 0x3, 0xf2, + 0x0, 0x0, 0x0, 0x3f, 0x20, 0x0, + + /* U+00A6 "¦" */ + 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x46, 0x0, + 0x46, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, + + /* U+00A7 "§" */ + 0x0, 0x6d, 0xfc, 0x40, 0x0, 0x4f, 0x84, 0xaf, + 0x20, 0x8, 0xd0, 0x0, 0xd5, 0x0, 0x4f, 0x70, + 0x0, 0x0, 0x1, 0xdf, 0xb2, 0x0, 0x1, 0xe7, + 0x4e, 0xf7, 0x0, 0x4f, 0x0, 0x1a, 0xf9, 0x2, + 0xf5, 0x0, 0x9, 0xf1, 0x6, 0xf7, 0x0, 0x2f, + 0x10, 0x3, 0xdc, 0x29, 0x80, 0x0, 0x0, 0x8f, + 0xc0, 0x0, 0x0, 0x0, 0x4f, 0x70, 0xa, 0xc0, + 0x0, 0xd9, 0x0, 0x5f, 0x94, 0x8f, 0x50, 0x0, + 0x6d, 0xfd, 0x60, 0x0, + + /* U+00A8 "¨" */ + 0x5a, 0x6, 0x98, 0xf0, 0x9d, + + /* U+00A9 "©" */ + 0x0, 0x5, 0xbd, 0xda, 0x40, 0x0, 0x1, 0xbc, + 0x52, 0x36, 0xda, 0x0, 0xb, 0x80, 0x9d, 0xd8, + 0xb, 0x90, 0x5b, 0xa, 0xa0, 0x1b, 0x60, 0xe3, + 0xc4, 0xf, 0x10, 0x0, 0x0, 0x79, 0xe0, 0x2e, + 0x0, 0x0, 0x0, 0x4b, 0xf0, 0xf, 0x0, 0x2, + 0x40, 0x3c, 0xd3, 0xa, 0x90, 0x2c, 0x60, 0x69, + 0x79, 0x0, 0xae, 0xe7, 0x0, 0xc4, 0xe, 0x50, + 0x0, 0x0, 0x8, 0xb0, 0x2, 0xe9, 0x20, 0x3, + 0xbc, 0x10, 0x0, 0x19, 0xef, 0xfd, 0x70, 0x0, + 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, + + /* U+00AA "ª" */ + 0xa, 0xec, 0x9a, 0x7d, 0x4, 0xf6, 0xb8, 0x0, + 0xe3, 0xa8, 0x0, 0xe2, 0x7c, 0x4, 0xf6, 0xa, + 0xec, 0x9a, + + /* U+00AB "«" */ + 0x0, 0x55, 0x5, 0x50, 0x2f, 0x22, 0xf3, 0xc, + 0x90, 0xba, 0x7, 0xf1, 0x6f, 0x20, 0xbd, 0xa, + 0xe0, 0x1, 0xf5, 0x1e, 0x60, 0x6, 0xe0, 0x6e, + 0x0, 0xb, 0x70, 0xb8, + + /* U+00AC "¬" */ + 0x1f, 0xff, 0xff, 0xff, 0x70, 0x66, 0x66, 0x66, + 0xe7, 0x0, 0x0, 0x0, 0xe, 0x70, 0x0, 0x0, + 0x0, 0xe7, 0x0, 0x0, 0x0, 0xc, 0x60, + + /* U+00AD "­" */ + 0x38, 0x88, 0x67, 0xff, 0xfd, + + /* U+00AE "®" */ + 0x0, 0x5, 0xbd, 0xda, 0x40, 0x0, 0x1, 0xbc, + 0x52, 0x36, 0xda, 0x0, 0xb, 0x80, 0x0, 0x0, + 0xb, 0x90, 0x5b, 0xa, 0xee, 0xe9, 0x0, 0xe3, + 0xc4, 0xb, 0x50, 0x1f, 0x20, 0x79, 0xe0, 0xb, + 0xff, 0xe7, 0x0, 0x4b, 0xf0, 0xb, 0x52, 0xd2, + 0x0, 0x3c, 0xd3, 0xb, 0x50, 0x6c, 0x0, 0x69, + 0x79, 0xb, 0x50, 0xe, 0x40, 0xc4, 0xe, 0x51, + 0x0, 0x1, 0x18, 0xb0, 0x2, 0xe9, 0x20, 0x3, + 0xbc, 0x10, 0x0, 0x19, 0xef, 0xfd, 0x70, 0x0, + 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, + + /* U+00B0 "°" */ + 0x2b, 0xd6, 0xb, 0x40, 0xc2, 0xd0, 0x8, 0x5b, + 0x41, 0xc2, 0x2c, 0xd6, 0x0, + + /* U+00B1 "±" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x50, + 0x0, 0x0, 0x0, 0xf5, 0x0, 0x0, 0x11, 0x1f, + 0x61, 0x10, 0x1f, 0xff, 0xff, 0xff, 0x70, 0x44, + 0x4f, 0x84, 0x42, 0x0, 0x0, 0xf5, 0x0, 0x0, + 0x0, 0xf, 0x50, 0x0, 0x0, 0x0, 0xf5, 0x0, + 0x0, 0x66, 0x66, 0x66, 0x62, 0x1f, 0xff, 0xff, + 0xff, 0x70, + + /* U+00B2 "²" */ + 0x1b, 0xee, 0x60, 0x69, 0x5, 0xf0, 0x0, 0x9, + 0xc0, 0x0, 0xad, 0x10, 0x1d, 0xa0, 0x0, 0xaf, + 0xff, 0xf0, + + /* U+00B3 "³" */ + 0x1c, 0xee, 0x50, 0x35, 0x9, 0xb0, 0x0, 0xaf, + 0x40, 0x0, 0x5, 0xe0, 0x89, 0x6, 0xe0, 0x1c, + 0xed, 0x40, + + /* U+00B5 "µ" */ + 0xe7, 0x0, 0x9, 0xce, 0x70, 0x0, 0x9c, 0xe7, + 0x0, 0x9, 0xce, 0x70, 0x0, 0x9c, 0xe7, 0x0, + 0x9, 0xce, 0x80, 0x0, 0xac, 0xeb, 0x0, 0xd, + 0xce, 0xf7, 0x29, 0xfc, 0xea, 0xcf, 0xc9, 0xce, + 0x70, 0x0, 0x0, 0xe7, 0x0, 0x0, 0xe, 0x70, + 0x0, 0x0, + + /* U+00B6 "¶" */ + 0x0, 0x6d, 0xff, 0xff, 0xf9, 0x7, 0xff, 0xfa, + 0x7e, 0xb4, 0xe, 0xff, 0xf6, 0xd, 0x70, 0xf, + 0xff, 0xf6, 0xd, 0x70, 0xd, 0xff, 0xf6, 0xd, + 0x70, 0x4, 0xff, 0xf6, 0xd, 0x70, 0x0, 0x28, + 0xf6, 0xd, 0x70, 0x0, 0x0, 0xe6, 0xd, 0x70, + 0x0, 0x0, 0xe6, 0xd, 0x70, 0x0, 0x0, 0xe6, + 0xd, 0x70, 0x0, 0x0, 0xe6, 0xd, 0x70, 0x0, + 0x0, 0xe6, 0xd, 0x70, 0x0, 0x0, 0xe6, 0xd, + 0x70, 0x0, 0x0, 0xe6, 0xd, 0x70, 0x0, 0x0, + 0xe6, 0xd, 0x70, + + /* U+00B7 "·" */ + 0x6b, 0x9, 0xf0, + + /* U+00BB "»" */ + 0x64, 0x6, 0x40, 0x4, 0xe1, 0x4e, 0x10, 0xc, + 0xa0, 0xbb, 0x0, 0x3f, 0x42, 0xf5, 0x0, 0xf8, + 0xe, 0x90, 0x8e, 0x7, 0xe1, 0x1f, 0x41, 0xe5, + 0x9, 0xa0, 0x8a, 0x0, + + /* U+00BD "½" */ + 0x0, 0x13, 0x0, 0x0, 0x0, 0x32, 0x0, 0x1, + 0xcb, 0x0, 0x0, 0x2, 0xe2, 0x0, 0x1e, 0xcb, + 0x0, 0x0, 0xd, 0x60, 0x0, 0x1, 0x6b, 0x0, + 0x0, 0x8b, 0x0, 0x0, 0x0, 0x6b, 0x0, 0x3, + 0xe1, 0x0, 0x0, 0x0, 0x6b, 0x0, 0xd, 0x50, + 0x0, 0x0, 0x0, 0x6b, 0x0, 0x9a, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xe0, 0x1b, 0xfe, 0x60, + 0x0, 0x0, 0x1e, 0x40, 0x6a, 0x5, 0xf0, 0x0, + 0x0, 0xa9, 0x0, 0x0, 0x7, 0xc0, 0x0, 0x5, + 0xd0, 0x0, 0x0, 0x8c, 0x10, 0x0, 0x1e, 0x30, + 0x0, 0xb, 0x90, 0x0, 0x0, 0xb7, 0x0, 0x0, + 0x8f, 0xff, 0xf1, 0x0, 0x30, 0x0, 0x0, 0x23, + 0x33, 0x30, + + /* U+0384 "΄" */ + 0x1, 0x52, 0x9, 0xe1, 0x1f, 0x40, + + /* U+0386 "Ά" */ + 0x0, 0xce, 0x1c, 0xf3, 0x0, 0x0, 0x3, 0xf3, + 0x2f, 0xd9, 0x0, 0x0, 0x2, 0x30, 0x8d, 0x7f, + 0x0, 0x0, 0x0, 0x0, 0xe8, 0x1f, 0x60, 0x0, + 0x0, 0x4, 0xf3, 0xb, 0xc0, 0x0, 0x0, 0xa, + 0xd0, 0x5, 0xf2, 0x0, 0x0, 0xf, 0x81, 0x11, + 0xf9, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0xbc, 0x44, 0x44, 0x6f, 0x50, 0x1, 0xf7, + 0x0, 0x0, 0xe, 0xb0, 0x7, 0xf1, 0x0, 0x0, + 0x8, 0xf2, 0xd, 0xc0, 0x0, 0x0, 0x3, 0xf8, + + /* U+0388 "Έ" */ + 0xd, 0xc0, 0xdf, 0xff, 0xff, 0xff, 0x65, 0xf2, + 0xd, 0xc7, 0x77, 0x77, 0x72, 0x33, 0x0, 0xda, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdb, 0x22, 0x22, 0x21, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0xdc, 0x55, 0x55, 0x54, 0x0, 0x0, 0xd, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xda, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdc, 0x77, 0x77, 0x77, 0x40, + 0x0, 0xd, 0xff, 0xff, 0xff, 0xfb, + + /* U+0389 "Ή" */ + 0xd, 0xc3, 0xf5, 0x0, 0x0, 0xb, 0xc5, 0xf2, + 0x3f, 0x50, 0x0, 0x0, 0xbc, 0x33, 0x3, 0xf5, + 0x0, 0x0, 0xb, 0xc0, 0x0, 0x3f, 0x50, 0x0, + 0x0, 0xbc, 0x0, 0x3, 0xf6, 0x22, 0x22, 0x2c, + 0xc0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xfc, 0x0, + 0x3, 0xf8, 0x55, 0x55, 0x5c, 0xc0, 0x0, 0x3f, + 0x50, 0x0, 0x0, 0xbc, 0x0, 0x3, 0xf5, 0x0, + 0x0, 0xb, 0xc0, 0x0, 0x3f, 0x50, 0x0, 0x0, + 0xbc, 0x0, 0x3, 0xf5, 0x0, 0x0, 0xb, 0xc0, + 0x0, 0x3f, 0x50, 0x0, 0x0, 0xbc, + + /* U+038A "Ί" */ + 0xd, 0xc3, 0xf5, 0x5f, 0x23, 0xf5, 0x33, 0x3, + 0xf5, 0x0, 0x3, 0xf5, 0x0, 0x3, 0xf5, 0x0, + 0x3, 0xf5, 0x0, 0x3, 0xf5, 0x0, 0x3, 0xf5, + 0x0, 0x3, 0xf5, 0x0, 0x3, 0xf5, 0x0, 0x3, + 0xf5, 0x0, 0x3, 0xf5, + + /* U+038C "Ό" */ + 0xd, 0xd0, 0x5b, 0xff, 0xd7, 0x0, 0x4, 0xf3, + 0x9f, 0xc7, 0x69, 0xfd, 0x10, 0x55, 0x6f, 0x70, + 0x0, 0x3, 0xfb, 0x0, 0xe, 0xc0, 0x0, 0x0, + 0x7, 0xf3, 0x2, 0xf6, 0x0, 0x0, 0x0, 0x1f, + 0x70, 0x4f, 0x40, 0x0, 0x0, 0x0, 0xf9, 0x4, + 0xf4, 0x0, 0x0, 0x0, 0xf, 0x90, 0x2f, 0x60, + 0x0, 0x0, 0x1, 0xf7, 0x0, 0xdc, 0x0, 0x0, + 0x0, 0x7f, 0x30, 0x5, 0xf7, 0x0, 0x0, 0x3f, + 0xb0, 0x0, 0x8, 0xfb, 0x76, 0x9f, 0xd1, 0x0, + 0x0, 0x4, 0xbe, 0xfd, 0x70, 0x0, + + /* U+038E "Ύ" */ + 0xd, 0xc0, 0xbf, 0x20, 0x0, 0x0, 0x9f, 0x25, + 0xf2, 0x1, 0xfb, 0x0, 0x0, 0x3f, 0x70, 0x33, + 0x0, 0x7, 0xf5, 0x0, 0xd, 0xc0, 0x0, 0x0, + 0x0, 0xc, 0xe1, 0x7, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0x91, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xcd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9e, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9e, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xe0, + 0x0, 0x0, + + /* U+038F "Ώ" */ + 0xd, 0xd0, 0x4b, 0xef, 0xc6, 0x0, 0x4, 0xf3, + 0x7f, 0xc7, 0x6b, 0xfa, 0x0, 0x55, 0x3f, 0xa0, + 0x0, 0x8, 0xf6, 0x0, 0xa, 0xf1, 0x0, 0x0, + 0xe, 0xd0, 0x0, 0xeb, 0x0, 0x0, 0x0, 0x9f, + 0x0, 0xf, 0x90, 0x0, 0x0, 0x6, 0xf2, 0x0, + 0xf9, 0x0, 0x0, 0x0, 0x7f, 0x10, 0xb, 0xc0, + 0x0, 0x0, 0x9, 0xd0, 0x0, 0x4f, 0x20, 0x0, + 0x0, 0xe7, 0x0, 0x0, 0xac, 0x0, 0x0, 0xac, + 0x0, 0x1, 0x77, 0xfd, 0x20, 0xcf, 0x77, 0x20, + 0x2f, 0xff, 0xf4, 0x2f, 0xff, 0xf4, + + /* U+0390 "ΐ" */ + 0x1f, 0x47, 0xcc, 0xa0, 0x93, 0x80, 0x65, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe7, 0x0, 0x0, 0xe, + 0x70, 0x0, 0x0, 0xe7, 0x0, 0x0, 0xe, 0x70, + 0x0, 0x0, 0xe7, 0x0, 0x0, 0xe, 0x70, 0x0, + 0x0, 0xe7, 0x0, 0x0, 0xe, 0x70, 0x0, 0x0, + 0xe7, 0x0, + + /* U+0391 "Α" */ + 0x0, 0x0, 0xc, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xd9, 0x0, 0x0, 0x0, 0x0, 0x8d, 0x6f, + 0x0, 0x0, 0x0, 0x0, 0xe8, 0x1f, 0x60, 0x0, + 0x0, 0x4, 0xf3, 0xb, 0xc0, 0x0, 0x0, 0xa, + 0xd0, 0x5, 0xf2, 0x0, 0x0, 0xf, 0x81, 0x11, + 0xf9, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0xbc, 0x44, 0x44, 0x6f, 0x50, 0x1, 0xf7, + 0x0, 0x0, 0xe, 0xb0, 0x7, 0xf1, 0x0, 0x0, + 0x8, 0xf2, 0xd, 0xc0, 0x0, 0x0, 0x3, 0xf8, + + /* U+0392 "Β" */ + 0xdf, 0xff, 0xfd, 0x91, 0xd, 0xd7, 0x77, 0x9f, + 0xc0, 0xdb, 0x0, 0x0, 0x6f, 0x2d, 0xb0, 0x0, + 0x4, 0xf3, 0xdb, 0x22, 0x24, 0xcc, 0xd, 0xff, + 0xff, 0xff, 0x30, 0xdc, 0x55, 0x57, 0xdf, 0x3d, + 0xb0, 0x0, 0x0, 0xea, 0xdb, 0x0, 0x0, 0xc, + 0xcd, 0xb0, 0x0, 0x1, 0xfa, 0xdd, 0x77, 0x78, + 0xef, 0x2d, 0xff, 0xff, 0xeb, 0x40, + + /* U+0393 "Γ" */ + 0xbf, 0xff, 0xff, 0xf7, 0xbe, 0x77, 0x77, 0x73, + 0xbc, 0x0, 0x0, 0x0, 0xbc, 0x0, 0x0, 0x0, + 0xbc, 0x0, 0x0, 0x0, 0xbc, 0x0, 0x0, 0x0, + 0xbc, 0x0, 0x0, 0x0, 0xbc, 0x0, 0x0, 0x0, + 0xbc, 0x0, 0x0, 0x0, 0xbc, 0x0, 0x0, 0x0, + 0xbc, 0x0, 0x0, 0x0, 0xbc, 0x0, 0x0, 0x0, + + /* U+0394 "Δ" */ + 0x0, 0x0, 0xc, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xd9, 0x0, 0x0, 0x0, 0x0, 0x8d, 0x7f, + 0x0, 0x0, 0x0, 0x0, 0xe8, 0x1f, 0x60, 0x0, + 0x0, 0x4, 0xf3, 0xb, 0xc0, 0x0, 0x0, 0xa, + 0xd0, 0x6, 0xf2, 0x0, 0x0, 0xf, 0x80, 0x0, + 0xf8, 0x0, 0x0, 0x5f, 0x20, 0x0, 0xae, 0x0, + 0x0, 0xbd, 0x0, 0x0, 0x4f, 0x50, 0x1, 0xf7, + 0x0, 0x0, 0xe, 0xb0, 0x7, 0xf8, 0x77, 0x77, + 0x7c, 0xf1, 0xd, 0xff, 0xff, 0xff, 0xff, 0xf8, + + /* U+0395 "Ε" */ + 0xbf, 0xff, 0xff, 0xff, 0x8b, 0xe7, 0x77, 0x77, + 0x73, 0xbc, 0x0, 0x0, 0x0, 0xb, 0xc0, 0x0, + 0x0, 0x0, 0xbc, 0x22, 0x22, 0x22, 0xb, 0xff, + 0xff, 0xff, 0xf2, 0xbd, 0x55, 0x55, 0x55, 0xb, + 0xc0, 0x0, 0x0, 0x0, 0xbc, 0x0, 0x0, 0x0, + 0xb, 0xc0, 0x0, 0x0, 0x0, 0xbe, 0x77, 0x77, + 0x77, 0x5b, 0xff, 0xff, 0xff, 0xfd, + + /* U+0396 "Ζ" */ + 0xf, 0xff, 0xff, 0xff, 0xf2, 0x7, 0x77, 0x77, + 0x7e, 0xf1, 0x0, 0x0, 0x0, 0x8f, 0x50, 0x0, + 0x0, 0x5, 0xf8, 0x0, 0x0, 0x0, 0x2f, 0xc0, + 0x0, 0x0, 0x0, 0xde, 0x10, 0x0, 0x0, 0xa, + 0xf4, 0x0, 0x0, 0x0, 0x6f, 0x70, 0x0, 0x0, + 0x3, 0xfa, 0x0, 0x0, 0x0, 0x1d, 0xd0, 0x0, + 0x0, 0x0, 0x9f, 0x97, 0x77, 0x77, 0x72, 0xbf, + 0xff, 0xff, 0xff, 0xf5, + + /* U+0397 "Η" */ + 0xbc, 0x0, 0x0, 0x4, 0xf4, 0xbc, 0x0, 0x0, + 0x4, 0xf4, 0xbc, 0x0, 0x0, 0x4, 0xf4, 0xbc, + 0x0, 0x0, 0x4, 0xf4, 0xbd, 0x22, 0x22, 0x25, + 0xf4, 0xbf, 0xff, 0xff, 0xff, 0xf4, 0xbd, 0x55, + 0x55, 0x57, 0xf4, 0xbc, 0x0, 0x0, 0x4, 0xf4, + 0xbc, 0x0, 0x0, 0x4, 0xf4, 0xbc, 0x0, 0x0, + 0x4, 0xf4, 0xbc, 0x0, 0x0, 0x4, 0xf4, 0xbc, + 0x0, 0x0, 0x4, 0xf4, + + /* U+0398 "Θ" */ + 0x0, 0x4, 0xbe, 0xfd, 0x80, 0x0, 0x0, 0x8f, + 0xc7, 0x69, 0xfd, 0x10, 0x5, 0xf8, 0x0, 0x0, + 0x2e, 0xc0, 0xd, 0xc0, 0x0, 0x0, 0x6, 0xf4, + 0x1f, 0x70, 0x11, 0x11, 0x0, 0xf8, 0x3f, 0x50, + 0xff, 0xff, 0x80, 0xea, 0x3f, 0x50, 0x44, 0x44, + 0x20, 0xea, 0x1f, 0x70, 0x0, 0x0, 0x0, 0xf8, + 0xc, 0xd0, 0x0, 0x0, 0x6, 0xf4, 0x4, 0xf8, + 0x0, 0x0, 0x2e, 0xc0, 0x0, 0x7f, 0xc7, 0x69, + 0xfd, 0x10, 0x0, 0x4, 0xbe, 0xfd, 0x80, 0x0, + + /* U+0399 "Ι" */ + 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, + 0x8f, 0x8f, 0x8f, 0x8f, + + /* U+039A "Κ" */ + 0xdb, 0x0, 0x0, 0x2e, 0xd1, 0xdb, 0x0, 0x2, + 0xed, 0x10, 0xdb, 0x0, 0x1e, 0xd1, 0x0, 0xdb, + 0x1, 0xdd, 0x10, 0x0, 0xdb, 0x1d, 0xe1, 0x0, + 0x0, 0xdc, 0xcf, 0xf2, 0x0, 0x0, 0xdf, 0xe3, + 0xec, 0x0, 0x0, 0xde, 0x20, 0x5f, 0x70, 0x0, + 0xdb, 0x0, 0xb, 0xf3, 0x0, 0xdb, 0x0, 0x1, + 0xed, 0x0, 0xdb, 0x0, 0x0, 0x5f, 0x90, 0xdb, + 0x0, 0x0, 0xa, 0xf4, + + /* U+039B "Λ" */ + 0x0, 0x0, 0xaf, 0x40, 0x0, 0x0, 0x0, 0xf, + 0xda, 0x0, 0x0, 0x0, 0x5, 0xf5, 0xf1, 0x0, + 0x0, 0x0, 0xba, 0xf, 0x60, 0x0, 0x0, 0x1f, + 0x40, 0xac, 0x0, 0x0, 0x7, 0xe0, 0x4, 0xf2, + 0x0, 0x0, 0xd9, 0x0, 0xf, 0x80, 0x0, 0x3f, + 0x30, 0x0, 0x9e, 0x0, 0x9, 0xe0, 0x0, 0x4, + 0xf4, 0x0, 0xf8, 0x0, 0x0, 0xe, 0xa0, 0x5f, + 0x20, 0x0, 0x0, 0x9f, 0xb, 0xd0, 0x0, 0x0, + 0x4, 0xf6, + + /* U+039C "Μ" */ + 0xcf, 0xa0, 0x0, 0x0, 0x1f, 0xf2, 0xcf, 0xf0, + 0x0, 0x0, 0x6f, 0xf2, 0xcc, 0xf4, 0x0, 0x0, + 0xbd, 0xf2, 0xca, 0xc9, 0x0, 0x1, 0xf7, 0xf2, + 0xca, 0x7e, 0x0, 0x6, 0xd5, 0xf2, 0xca, 0x2f, + 0x30, 0xb, 0x75, 0xf2, 0xca, 0xc, 0x90, 0xf, + 0x25, 0xf2, 0xca, 0x7, 0xe0, 0x5d, 0x5, 0xf2, + 0xca, 0x2, 0xf3, 0xb8, 0x5, 0xf2, 0xca, 0x0, + 0xd8, 0xf2, 0x5, 0xf2, 0xca, 0x0, 0x8f, 0xd0, + 0x5, 0xf2, 0xca, 0x0, 0x2f, 0x80, 0x5, 0xf2, + + /* U+039D "Ν" */ + 0xbf, 0x20, 0x0, 0x2, 0xf4, 0xbf, 0xc0, 0x0, + 0x2, 0xf4, 0xbf, 0xf6, 0x0, 0x2, 0xf4, 0xbb, + 0xaf, 0x10, 0x2, 0xf4, 0xbb, 0x1f, 0xb0, 0x2, + 0xf4, 0xbb, 0x6, 0xf5, 0x2, 0xf4, 0xbb, 0x0, + 0xce, 0x12, 0xf4, 0xbb, 0x0, 0x2f, 0x92, 0xf4, + 0xbb, 0x0, 0x7, 0xf6, 0xf4, 0xbb, 0x0, 0x0, + 0xdf, 0xf4, 0xbb, 0x0, 0x0, 0x3f, 0xf4, 0xbb, + 0x0, 0x0, 0x9, 0xf4, + + /* U+039E "Ξ" */ + 0xf, 0xff, 0xff, 0xff, 0xf5, 0x6, 0x77, 0x77, + 0x77, 0x72, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x11, 0x11, 0x11, + 0x10, 0x3, 0xff, 0xff, 0xff, 0x90, 0x0, 0x44, + 0x44, 0x44, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0x77, 0x77, 0x77, 0x73, 0x2f, + 0xff, 0xff, 0xff, 0xf8, + + /* U+039F "Ο" */ + 0x0, 0x4, 0xbe, 0xfd, 0x80, 0x0, 0x0, 0x8f, + 0xc7, 0x69, 0xfd, 0x10, 0x5, 0xf8, 0x0, 0x0, + 0x2e, 0xc0, 0xd, 0xc0, 0x0, 0x0, 0x6, 0xf4, + 0x1f, 0x70, 0x0, 0x0, 0x0, 0xf8, 0x3f, 0x50, + 0x0, 0x0, 0x0, 0xea, 0x3f, 0x50, 0x0, 0x0, + 0x0, 0xea, 0x1f, 0x70, 0x0, 0x0, 0x0, 0xf8, + 0xc, 0xd0, 0x0, 0x0, 0x6, 0xf4, 0x4, 0xf8, + 0x0, 0x0, 0x2e, 0xc0, 0x0, 0x7f, 0xc7, 0x69, + 0xfd, 0x10, 0x0, 0x4, 0xbe, 0xfd, 0x80, 0x0, + + /* U+03A0 "Π" */ + 0xbf, 0xff, 0xff, 0xff, 0xf4, 0xbe, 0x77, 0x77, + 0x79, 0xf4, 0xbc, 0x0, 0x0, 0x4, 0xf4, 0xbc, + 0x0, 0x0, 0x4, 0xf4, 0xbc, 0x0, 0x0, 0x4, + 0xf4, 0xbc, 0x0, 0x0, 0x4, 0xf4, 0xbc, 0x0, + 0x0, 0x4, 0xf4, 0xbc, 0x0, 0x0, 0x4, 0xf4, + 0xbc, 0x0, 0x0, 0x4, 0xf4, 0xbc, 0x0, 0x0, + 0x4, 0xf4, 0xbc, 0x0, 0x0, 0x4, 0xf4, 0xbc, + 0x0, 0x0, 0x4, 0xf4, + + /* U+03A1 "Ρ" */ + 0xcf, 0xff, 0xff, 0xc6, 0xc, 0xd7, 0x77, 0x7c, + 0xf6, 0xcc, 0x0, 0x0, 0xd, 0xdc, 0xc0, 0x0, + 0x0, 0x9f, 0xcc, 0x0, 0x0, 0xc, 0xdc, 0xc2, + 0x22, 0x39, 0xf7, 0xcf, 0xff, 0xff, 0xfa, 0xc, + 0xd5, 0x54, 0x41, 0x0, 0xcc, 0x0, 0x0, 0x0, + 0xc, 0xc0, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x0, + 0x0, 0xc, 0xc0, 0x0, 0x0, 0x0, + + /* U+03A3 "Σ" */ + 0xdf, 0xff, 0xff, 0xff, 0xc, 0xf7, 0x77, 0x77, + 0x60, 0x2e, 0xb0, 0x0, 0x0, 0x0, 0x3f, 0xa0, + 0x0, 0x0, 0x0, 0x4f, 0x80, 0x0, 0x0, 0x0, + 0x6f, 0x60, 0x0, 0x0, 0xb, 0xf2, 0x0, 0x0, + 0x8, 0xf4, 0x0, 0x0, 0x5, 0xf7, 0x0, 0x0, + 0x3, 0xfa, 0x0, 0x0, 0x0, 0xcf, 0x77, 0x77, + 0x77, 0x1d, 0xff, 0xff, 0xff, 0xf4, + + /* U+03A4 "Τ" */ + 0xaf, 0xff, 0xff, 0xff, 0xf6, 0x47, 0x77, 0xec, + 0x77, 0x72, 0x0, 0x0, 0xea, 0x0, 0x0, 0x0, + 0x0, 0xea, 0x0, 0x0, 0x0, 0x0, 0xea, 0x0, + 0x0, 0x0, 0x0, 0xea, 0x0, 0x0, 0x0, 0x0, + 0xea, 0x0, 0x0, 0x0, 0x0, 0xea, 0x0, 0x0, + 0x0, 0x0, 0xea, 0x0, 0x0, 0x0, 0x0, 0xea, + 0x0, 0x0, 0x0, 0x0, 0xea, 0x0, 0x0, 0x0, + 0x0, 0xea, 0x0, 0x0, + + /* U+03A5 "Υ" */ + 0xaf, 0x30, 0x0, 0x0, 0x8f, 0x31, 0xec, 0x0, + 0x0, 0x2f, 0x80, 0x5, 0xf7, 0x0, 0xc, 0xd0, + 0x0, 0xb, 0xf1, 0x6, 0xf3, 0x0, 0x0, 0x1f, + 0xa1, 0xe9, 0x0, 0x0, 0x0, 0x7f, 0xcd, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0x40, 0x0, 0x0, 0x0, + 0x8, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0x0, 0x0, 0x0, 0x0, 0x8, 0xf0, + 0x0, 0x0, + + /* U+03A6 "Φ" */ + 0x0, 0x0, 0x6, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0x20, 0x0, 0x0, 0x0, 0x2a, 0xff, + 0xff, 0xe9, 0x10, 0x0, 0x3f, 0xd7, 0x9f, 0x68, + 0xfe, 0x10, 0xd, 0xd0, 0x6, 0xf2, 0x2, 0xfa, + 0x2, 0xf6, 0x0, 0x6f, 0x20, 0xa, 0xf0, 0x4f, + 0x40, 0x6, 0xf2, 0x0, 0x7f, 0x13, 0xf6, 0x0, + 0x6f, 0x20, 0x9, 0xf0, 0xe, 0xc0, 0x6, 0xf2, + 0x1, 0xeb, 0x0, 0x5f, 0xb4, 0x7f, 0x34, 0xdf, + 0x20, 0x0, 0x5d, 0xff, 0xff, 0xfc, 0x20, 0x0, + 0x0, 0x2, 0x8f, 0x51, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xf2, 0x0, 0x0, 0x0, + + /* U+03A7 "Χ" */ + 0x1f, 0xb0, 0x0, 0x0, 0xbd, 0x0, 0x6f, 0x60, + 0x0, 0x7f, 0x30, 0x0, 0xbf, 0x20, 0x3f, 0x70, + 0x0, 0x1, 0xec, 0xd, 0xc0, 0x0, 0x0, 0x5, + 0xfd, 0xe1, 0x0, 0x0, 0x0, 0xb, 0xf6, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xc0, 0x0, 0x0, 0x0, + 0xbe, 0x6f, 0x70, 0x0, 0x0, 0x7f, 0x40, 0xaf, + 0x30, 0x0, 0x2f, 0x90, 0x1, 0xed, 0x0, 0xd, + 0xd0, 0x0, 0x4, 0xf8, 0x9, 0xf3, 0x0, 0x0, + 0xa, 0xf3, + + /* U+03A8 "Ψ" */ + 0xf8, 0x0, 0x1f, 0x70, 0x2, 0xf6, 0xf8, 0x0, + 0x1f, 0x70, 0x2, 0xf6, 0xf8, 0x0, 0x1f, 0x70, + 0x2, 0xf6, 0xf8, 0x0, 0x1f, 0x70, 0x2, 0xf5, + 0xea, 0x0, 0x1f, 0x70, 0x4, 0xf4, 0xae, 0x10, + 0x1f, 0x70, 0xa, 0xf1, 0x3f, 0xd5, 0x3f, 0x83, + 0xaf, 0x90, 0x4, 0xdf, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x2, 0x4f, 0x93, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0x70, 0x0, 0x0, 0x0, 0x0, 0x1f, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0x70, 0x0, 0x0, + + /* U+03A9 "Ω" */ + 0x0, 0x5, 0xce, 0xfc, 0x50, 0x0, 0x0, 0x9f, + 0xc7, 0x6c, 0xf9, 0x0, 0x5, 0xf9, 0x0, 0x0, + 0x9f, 0x40, 0xc, 0xe0, 0x0, 0x0, 0x1e, 0xb0, + 0xf, 0xa0, 0x0, 0x0, 0xa, 0xf0, 0x1f, 0x70, + 0x0, 0x0, 0x8, 0xf1, 0xf, 0x80, 0x0, 0x0, + 0x8, 0xf0, 0xc, 0xa0, 0x0, 0x0, 0xa, 0xc0, + 0x6, 0xf1, 0x0, 0x0, 0x1f, 0x50, 0x0, 0xbb, + 0x0, 0x0, 0xbb, 0x0, 0x17, 0x7f, 0xc1, 0x1c, + 0xf7, 0x71, 0x3f, 0xff, 0xf3, 0x3f, 0xff, 0xf3, + + /* U+03AA "Ϊ" */ + 0xb, 0x51, 0xb4, 0xf, 0x71, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0x0, 0x0, 0x8f, 0x0, 0x0, + 0x8f, 0x0, 0x0, 0x8f, 0x0, 0x0, 0x8f, 0x0, + 0x0, 0x8f, 0x0, 0x0, 0x8f, 0x0, 0x0, 0x8f, + 0x0, 0x0, 0x8f, 0x0, 0x0, 0x8f, 0x0, 0x0, + 0x8f, 0x0, 0x0, 0x8f, 0x0, + + /* U+03AB "Ϋ" */ + 0x0, 0xa, 0x60, 0xa5, 0x0, 0x0, 0x0, 0xe9, + 0xf, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xf3, 0x0, 0x0, 0x8, 0xf3, 0x1e, 0xc0, + 0x0, 0x2, 0xf8, 0x0, 0x5f, 0x70, 0x0, 0xcd, + 0x0, 0x0, 0xbf, 0x10, 0x6f, 0x30, 0x0, 0x1, + 0xfa, 0x1e, 0x90, 0x0, 0x0, 0x7, 0xfc, 0xd0, + 0x0, 0x0, 0x0, 0xc, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0x0, 0x0, 0x0, 0x0, 0x8, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0x0, 0x0, 0x0, + + /* U+03AC "ά" */ + 0x0, 0x0, 0x8f, 0x20, 0x0, 0x0, 0xf, 0x60, + 0x0, 0x0, 0x1, 0x40, 0x0, 0x0, 0x9, 0xef, + 0xa1, 0xe8, 0xa, 0xe4, 0x18, 0xdf, 0x42, 0xf7, + 0x0, 0xd, 0xf0, 0x5f, 0x30, 0x0, 0x9d, 0x6, + 0xf2, 0x0, 0x8, 0xa0, 0x4f, 0x30, 0x0, 0xad, + 0x1, 0xf7, 0x0, 0xe, 0xf0, 0x9, 0xe4, 0x1a, + 0xdf, 0x30, 0x9, 0xff, 0xa1, 0xe7, + + /* U+03AD "έ" */ + 0x0, 0x6, 0xf4, 0x0, 0x0, 0xd8, 0x0, 0x0, + 0x4, 0x0, 0x0, 0x1b, 0xfe, 0x80, 0xb, 0xd5, + 0x8e, 0x20, 0xf6, 0x0, 0x0, 0xc, 0xc2, 0x0, + 0x0, 0x3f, 0xf9, 0x0, 0xe, 0xc4, 0x20, 0x3, + 0xf4, 0x0, 0x0, 0xe, 0xc4, 0x6e, 0x70, 0x3c, + 0xfe, 0x90, + + /* U+03AE "ή" */ + 0x0, 0xa, 0xe1, 0x0, 0x1, 0xf4, 0x0, 0x0, + 0x24, 0x0, 0xe, 0x7a, 0xff, 0x90, 0xef, 0x72, + 0x5f, 0x8e, 0xb0, 0x0, 0xbc, 0xe8, 0x0, 0x9, + 0xde, 0x80, 0x0, 0x9d, 0xe8, 0x0, 0x9, 0xde, + 0x80, 0x0, 0x9d, 0xe8, 0x0, 0x9, 0xde, 0x80, + 0x0, 0x9d, 0x0, 0x0, 0x9, 0xd0, 0x0, 0x0, + 0x9d, 0x0, 0x0, 0x9, 0xd0, + + /* U+03AF "ί" */ + 0x5, 0xf5, 0xc, 0x90, 0x5, 0x0, 0xe, 0x70, + 0xe, 0x70, 0xe, 0x70, 0xe, 0x70, 0xe, 0x70, + 0xe, 0x70, 0xe, 0x70, 0xe, 0x70, 0xe, 0x70, + + /* U+03B0 "ΰ" */ + 0x7e, 0xd, 0x8f, 0x34, 0x83, 0x51, 0x92, 0x0, + 0x0, 0x0, 0xf, 0x70, 0x0, 0xbb, 0xf7, 0x0, + 0xb, 0xbf, 0x70, 0x0, 0xbb, 0xf7, 0x0, 0xb, + 0xbf, 0x70, 0x0, 0xbb, 0xe8, 0x0, 0xb, 0xac, + 0xb0, 0x0, 0xe8, 0x6f, 0x84, 0xaf, 0x20, 0x7e, + 0xfc, 0x40, + + /* U+03B1 "α" */ + 0x0, 0x9e, 0xfa, 0x1e, 0x80, 0xae, 0x41, 0x8d, + 0xf4, 0x2f, 0x70, 0x0, 0xdf, 0x5, 0xf3, 0x0, + 0x9, 0xd0, 0x6f, 0x20, 0x0, 0x8a, 0x4, 0xf3, + 0x0, 0xa, 0xd0, 0x1f, 0x70, 0x0, 0xef, 0x0, + 0x9e, 0x41, 0xad, 0xf3, 0x0, 0x9f, 0xfa, 0x1e, + 0x70, + + /* U+03B2 "β" */ + 0x5, 0xdf, 0xe8, 0x0, 0x5f, 0x84, 0x7f, 0x70, + 0xca, 0x0, 0x9, 0xb0, 0xe8, 0x0, 0x3d, 0x60, + 0xe8, 0x4f, 0xf6, 0x0, 0xe8, 0x2, 0x6f, 0x80, + 0xe8, 0x0, 0x6, 0xf2, 0xe8, 0x0, 0x1, 0xf6, + 0xe9, 0x0, 0x0, 0xf6, 0xec, 0x0, 0x4, 0xf3, + 0xef, 0xa2, 0x3d, 0xc0, 0xe8, 0x9e, 0xfa, 0x10, + 0xe8, 0x0, 0x0, 0x0, 0xe8, 0x0, 0x0, 0x0, + 0xe8, 0x0, 0x0, 0x0, + + /* U+03B3 "γ" */ + 0x9d, 0x0, 0x0, 0xca, 0x4f, 0x20, 0x2, 0xf4, + 0xe, 0x80, 0x7, 0xe0, 0x8, 0xd0, 0xd, 0x80, + 0x3, 0xf3, 0x3f, 0x30, 0x0, 0xd8, 0x8d, 0x0, + 0x0, 0x7e, 0xe7, 0x0, 0x0, 0x2f, 0xf2, 0x0, + 0x0, 0xc, 0xc0, 0x0, 0x0, 0xb, 0xb0, 0x0, + 0x0, 0xb, 0xb0, 0x0, 0x0, 0xb, 0xb0, 0x0, + + /* U+03B4 "δ" */ + 0xa, 0xff, 0xff, 0xfa, 0x0, 0x3d, 0xb3, 0x33, + 0x20, 0x0, 0x1a, 0xa0, 0x0, 0x0, 0x9, 0xef, + 0xd2, 0x0, 0xa, 0xf6, 0x27, 0xe3, 0x2, 0xf7, + 0x0, 0x8, 0xd0, 0x5f, 0x20, 0x0, 0x3f, 0x36, + 0xf0, 0x0, 0x2, 0xf5, 0x4f, 0x20, 0x0, 0x3f, + 0x41, 0xf8, 0x0, 0x9, 0xf1, 0x8, 0xf8, 0x48, + 0xf8, 0x0, 0x8, 0xef, 0xd6, 0x0, + + /* U+03B5 "ε" */ + 0x1, 0xbf, 0xe8, 0x0, 0xbd, 0x58, 0xe2, 0xf, + 0x60, 0x0, 0x0, 0xcc, 0x20, 0x0, 0x3, 0xff, + 0x90, 0x0, 0xec, 0x42, 0x0, 0x3f, 0x40, 0x0, + 0x0, 0xec, 0x46, 0xe7, 0x3, 0xcf, 0xe9, 0x0, + + /* U+03B6 "ζ" */ + 0x2, 0xff, 0xff, 0xe0, 0x3, 0x38, 0xf5, 0x0, + 0x6, 0xe2, 0x0, 0x4, 0xf3, 0x0, 0x1, 0xe5, + 0x0, 0x0, 0x9c, 0x0, 0x0, 0x1f, 0x50, 0x0, + 0x5, 0xf1, 0x0, 0x0, 0x6f, 0x0, 0x0, 0x5, + 0xf4, 0x0, 0x0, 0x1f, 0xfc, 0xa6, 0x0, 0x4d, + 0xff, 0xf8, 0x0, 0x0, 0x1c, 0xb0, 0x0, 0x3, + 0xd7, 0x0, 0x1, 0xe8, 0x0, + + /* U+03B7 "η" */ + 0xe7, 0xaf, 0xf9, 0xe, 0xf7, 0x25, 0xf8, 0xeb, + 0x0, 0xb, 0xce, 0x80, 0x0, 0x9d, 0xe8, 0x0, + 0x9, 0xde, 0x80, 0x0, 0x9d, 0xe8, 0x0, 0x9, + 0xde, 0x80, 0x0, 0x9d, 0xe8, 0x0, 0x9, 0xd0, + 0x0, 0x0, 0x9d, 0x0, 0x0, 0x9, 0xd0, 0x0, + 0x0, 0x9d, + + /* U+03B8 "θ" */ + 0x0, 0x6d, 0xfd, 0x50, 0x0, 0x4f, 0x84, 0x9f, + 0x30, 0xc, 0xa0, 0x0, 0xbb, 0x1, 0xf5, 0x0, + 0x6, 0xf0, 0x3f, 0x30, 0x0, 0x4f, 0x14, 0xff, + 0xff, 0xff, 0xf2, 0x4f, 0x53, 0x33, 0x6f, 0x23, + 0xf4, 0x0, 0x5, 0xf1, 0x1f, 0x60, 0x0, 0x8f, + 0x0, 0xcc, 0x0, 0xd, 0xb0, 0x4, 0xf9, 0x4a, + 0xf3, 0x0, 0x6, 0xdf, 0xd5, 0x0, + + /* U+03B9 "ι" */ + 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, + 0xe7, + + /* U+03BA "κ" */ + 0xf7, 0x0, 0xaf, 0x3f, 0x70, 0x9f, 0x30, 0xf7, + 0x9f, 0x30, 0xf, 0xdf, 0x40, 0x0, 0xff, 0xf8, + 0x0, 0xf, 0x77, 0xf5, 0x0, 0xf7, 0xb, 0xf2, + 0xf, 0x70, 0x1d, 0xd0, 0xf7, 0x0, 0x3f, 0x90, + + /* U+03BB "λ" */ + 0x0, 0xcb, 0x0, 0x0, 0x0, 0x6f, 0x10, 0x0, + 0x0, 0x1f, 0x60, 0x0, 0x0, 0xd, 0xc0, 0x0, + 0x0, 0x1f, 0xf1, 0x0, 0x0, 0x7f, 0xf7, 0x0, + 0x0, 0xd9, 0x9d, 0x0, 0x3, 0xf4, 0x4f, 0x30, + 0x8, 0xe0, 0xe, 0x80, 0xe, 0x80, 0x9, 0xe0, + 0x4f, 0x30, 0x3, 0xf4, 0xad, 0x0, 0x0, 0xd9, + + /* U+03BC "μ" */ + 0xe7, 0x0, 0x9, 0xce, 0x70, 0x0, 0x9c, 0xe7, + 0x0, 0x9, 0xce, 0x70, 0x0, 0x9c, 0xe7, 0x0, + 0x9, 0xce, 0x80, 0x0, 0xac, 0xeb, 0x0, 0xd, + 0xce, 0xf7, 0x29, 0xfc, 0xea, 0xcf, 0xc9, 0xce, + 0x70, 0x0, 0x0, 0xe7, 0x0, 0x0, 0xe, 0x70, + 0x0, 0x0, + + /* U+03BD "ν" */ + 0xad, 0x0, 0x0, 0xca, 0x4f, 0x20, 0x2, 0xf4, + 0xe, 0x80, 0x7, 0xe0, 0x9, 0xd0, 0xc, 0x90, + 0x3, 0xf2, 0x2f, 0x30, 0x0, 0xd8, 0x7e, 0x0, + 0x0, 0x8c, 0xc8, 0x0, 0x0, 0x2f, 0xf3, 0x0, + 0x0, 0xd, 0xd0, 0x0, + + /* U+03BE "ξ" */ + 0x1, 0x9e, 0xff, 0x0, 0xad, 0x54, 0x30, 0xb, + 0xb2, 0x0, 0x0, 0x1a, 0xff, 0xf0, 0x0, 0xae, + 0x63, 0x0, 0x9e, 0x10, 0x0, 0x1f, 0x60, 0x0, + 0x3, 0xf3, 0x0, 0x0, 0x2f, 0x50, 0x0, 0x0, + 0xdd, 0x40, 0x0, 0x3, 0xdf, 0xfc, 0x20, 0x0, + 0x37, 0xeb, 0x0, 0x0, 0x8, 0xd0, 0x0, 0x7, + 0xe8, 0x0, 0x2, 0xe8, 0x0, + + /* U+03BF "ο" */ + 0x0, 0x7d, 0xfd, 0x60, 0x0, 0x9f, 0x84, 0x8f, + 0x70, 0x2f, 0x70, 0x0, 0x9f, 0x5, 0xf2, 0x0, + 0x3, 0xf4, 0x6f, 0x0, 0x0, 0x2f, 0x55, 0xf2, + 0x0, 0x3, 0xf3, 0x2f, 0x70, 0x0, 0x9f, 0x0, + 0x9f, 0x84, 0x8f, 0x80, 0x0, 0x7e, 0xfd, 0x60, + 0x0, + + /* U+03C0 "π" */ + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xb2, 0x39, 0xf3, + 0x33, 0xad, 0x32, 0x0, 0x7f, 0x0, 0x9, 0xd0, + 0x0, 0x7, 0xf0, 0x0, 0x9d, 0x0, 0x0, 0x7f, + 0x0, 0x9, 0xd0, 0x0, 0x7, 0xf0, 0x0, 0x9d, + 0x0, 0x0, 0x7f, 0x0, 0x9, 0xd0, 0x0, 0x7, + 0xf0, 0x0, 0x9d, 0x0, 0x0, 0x7f, 0x0, 0x9, + 0xd0, 0x0, + + /* U+03C1 "ρ" */ + 0x5, 0xdf, 0xe8, 0x0, 0x3f, 0xa4, 0x7f, 0xa0, + 0xad, 0x0, 0x5, 0xf3, 0xe9, 0x0, 0x0, 0xf7, + 0xf7, 0x0, 0x0, 0xe8, 0xf8, 0x0, 0x0, 0xf7, + 0xfd, 0x0, 0x5, 0xf3, 0xff, 0xa4, 0x6f, 0xa0, + 0xf8, 0xbf, 0xe9, 0x0, 0xf7, 0x0, 0x0, 0x0, + 0xf7, 0x0, 0x0, 0x0, 0xf7, 0x0, 0x0, 0x0, + + /* U+03C2 "ς" */ + 0x0, 0x19, 0xdf, 0xe5, 0x2, 0xed, 0x64, 0x52, + 0xc, 0xc0, 0x0, 0x0, 0x2f, 0x40, 0x0, 0x0, + 0x4f, 0x10, 0x0, 0x0, 0x3f, 0x40, 0x0, 0x0, + 0xc, 0xd2, 0x0, 0x0, 0x1, 0xcf, 0xc7, 0x10, + 0x0, 0x3, 0x8e, 0xc0, 0x0, 0x0, 0x5, 0xf2, + 0x0, 0x5, 0x7d, 0xe0, 0x0, 0xd, 0xfb, 0x20, + + /* U+03C3 "σ" */ + 0x0, 0x7e, 0xff, 0xff, 0xf8, 0xa, 0xfa, 0x7b, + 0xfb, 0x63, 0x2f, 0x80, 0x0, 0xae, 0x0, 0x6f, + 0x20, 0x0, 0x4f, 0x30, 0x7f, 0x0, 0x0, 0x2f, + 0x40, 0x6f, 0x10, 0x0, 0x3f, 0x30, 0x2f, 0x60, + 0x0, 0x9f, 0x0, 0xa, 0xf7, 0x48, 0xf7, 0x0, + 0x0, 0x8e, 0xfd, 0x60, 0x0, + + /* U+03C4 "τ" */ + 0xaf, 0xff, 0xff, 0x23, 0x9f, 0x33, 0x0, 0x7f, + 0x0, 0x0, 0x7f, 0x0, 0x0, 0x7f, 0x0, 0x0, + 0x7f, 0x0, 0x0, 0x7f, 0x0, 0x0, 0x7f, 0x0, + 0x0, 0x7f, 0x0, + + /* U+03C5 "υ" */ + 0xf7, 0x0, 0xb, 0xbf, 0x70, 0x0, 0xbb, 0xf7, + 0x0, 0xb, 0xbf, 0x70, 0x0, 0xbb, 0xf7, 0x0, + 0xb, 0xbe, 0x80, 0x0, 0xba, 0xcb, 0x0, 0xe, + 0x86, 0xf8, 0x4a, 0xf2, 0x7, 0xef, 0xc4, 0x0, + + /* U+03C6 "φ" */ + 0x0, 0x9b, 0x1c, 0xfc, 0x30, 0xa, 0xe4, 0x6f, + 0x59, 0xf1, 0x2f, 0x50, 0x7f, 0x0, 0xe8, 0x5f, + 0x10, 0x7f, 0x0, 0xbc, 0x6f, 0x0, 0x7f, 0x0, + 0xbc, 0x4f, 0x30, 0x7f, 0x0, 0xe9, 0xe, 0xb0, + 0x7f, 0x6, 0xf3, 0x5, 0xfb, 0xaf, 0x9f, 0x80, + 0x0, 0x4c, 0xff, 0xc5, 0x0, 0x0, 0x0, 0x7f, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0x0, 0x0, + + /* U+03C7 "χ" */ + 0x6f, 0x20, 0x0, 0xbd, 0x0, 0xd9, 0x0, 0x3f, + 0x50, 0x6, 0xf1, 0xa, 0xc0, 0x0, 0xd, 0x92, + 0xf4, 0x0, 0x0, 0x6f, 0xbc, 0x0, 0x0, 0x0, + 0xef, 0x40, 0x0, 0x0, 0xe, 0xf5, 0x0, 0x0, + 0x7, 0xe9, 0xd0, 0x0, 0x1, 0xf7, 0x1f, 0x60, + 0x0, 0x8e, 0x0, 0x9e, 0x0, 0x1f, 0x70, 0x1, + 0xf7, 0x9, 0xe0, 0x0, 0x9, 0xe0, + + /* U+03C8 "ψ" */ + 0xf, 0x50, 0xf, 0x60, 0xf, 0x70, 0xf5, 0x0, + 0xf6, 0x0, 0xf7, 0xf, 0x50, 0xf, 0x60, 0xf, + 0x70, 0xf5, 0x0, 0xf6, 0x0, 0xf7, 0xf, 0x50, + 0xf, 0x60, 0xf, 0x70, 0xf6, 0x0, 0xf6, 0x0, + 0xf6, 0xd, 0xa0, 0xf, 0x60, 0x4f, 0x30, 0x5f, + 0xa4, 0xf9, 0x7e, 0xc0, 0x0, 0x5c, 0xff, 0xfe, + 0x80, 0x0, 0x0, 0x0, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0xf, 0x60, 0x0, 0x0, 0x0, 0x0, 0xf6, + 0x0, 0x0, + + /* U+03C9 "ω" */ + 0x5, 0xf1, 0x0, 0x0, 0x9, 0xc0, 0xb, 0xb0, + 0x0, 0x0, 0x3, 0xf3, 0xf, 0x60, 0x5, 0xb0, + 0x0, 0xe8, 0x3f, 0x30, 0x7, 0xf0, 0x0, 0xbb, + 0x4f, 0x20, 0x7, 0xf0, 0x0, 0xac, 0x3f, 0x30, + 0x7, 0xf0, 0x0, 0xbb, 0x1f, 0x70, 0xa, 0xf2, + 0x0, 0xe8, 0x9, 0xe4, 0x6e, 0x9c, 0x3a, 0xf2, + 0x0, 0xaf, 0xd4, 0x9, 0xfe, 0x50, + + /* U+03CA "ϊ" */ + 0x7f, 0x8, 0xf4, 0xb0, 0x5a, 0x0, 0x0, 0x0, + 0xe, 0x70, 0x0, 0xe7, 0x0, 0xe, 0x70, 0x0, + 0xe7, 0x0, 0xe, 0x70, 0x0, 0xe7, 0x0, 0xe, + 0x70, 0x0, 0xe7, 0x0, 0xe, 0x70, + + /* U+03CB "ϋ" */ + 0xd, 0xa0, 0xe9, 0x0, 0x87, 0x9, 0x60, 0x0, + 0x0, 0x0, 0xf, 0x70, 0x0, 0xbb, 0xf7, 0x0, + 0xb, 0xbf, 0x70, 0x0, 0xbb, 0xf7, 0x0, 0xb, + 0xbf, 0x70, 0x0, 0xbb, 0xe8, 0x0, 0xb, 0xac, + 0xb0, 0x0, 0xe8, 0x6f, 0x84, 0xaf, 0x20, 0x7e, + 0xfc, 0x40, + + /* U+03CC "ό" */ + 0x0, 0x0, 0xae, 0x10, 0x0, 0x0, 0x1f, 0x40, + 0x0, 0x0, 0x2, 0x40, 0x0, 0x0, 0x7, 0xdf, + 0xd6, 0x0, 0x9, 0xf8, 0x48, 0xf7, 0x2, 0xf7, + 0x0, 0x9, 0xf0, 0x5f, 0x20, 0x0, 0x3f, 0x46, + 0xf0, 0x0, 0x2, 0xf5, 0x5f, 0x20, 0x0, 0x3f, + 0x32, 0xf7, 0x0, 0x9, 0xf0, 0x9, 0xf8, 0x48, + 0xf8, 0x0, 0x7, 0xef, 0xd6, 0x0, + + /* U+03CD "ύ" */ + 0x0, 0xb, 0xe1, 0x0, 0x2, 0xf3, 0x0, 0x0, + 0x23, 0x0, 0xf, 0x70, 0x0, 0xbb, 0xf7, 0x0, + 0xb, 0xbf, 0x70, 0x0, 0xbb, 0xf7, 0x0, 0xb, + 0xbf, 0x70, 0x0, 0xbb, 0xe8, 0x0, 0xb, 0xac, + 0xb0, 0x0, 0xe8, 0x6f, 0x84, 0xaf, 0x20, 0x7e, + 0xfc, 0x40, + + /* U+03CE "ώ" */ + 0x0, 0x0, 0x0, 0xdc, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x3, 0x20, + 0x0, 0x0, 0x5, 0xf1, 0x0, 0x0, 0x9, 0xc0, + 0xb, 0xb0, 0x0, 0x0, 0x3, 0xf3, 0xf, 0x60, + 0x5, 0xb0, 0x0, 0xe8, 0x3f, 0x30, 0x7, 0xf0, + 0x0, 0xbb, 0x4f, 0x20, 0x7, 0xf0, 0x0, 0xac, + 0x3f, 0x30, 0x7, 0xf0, 0x0, 0xbb, 0x1f, 0x70, + 0xa, 0xf2, 0x0, 0xe8, 0x9, 0xe4, 0x6e, 0x9c, + 0x3a, 0xf2, 0x0, 0xaf, 0xd4, 0x9, 0xfe, 0x50, + + /* U+03F4 "ϴ" */ + 0x2f, 0x39, 0xad, 0x81, 0x92, 0x80, 0x84 +}; + + +/*--------------------- + * GLYPH DESCRIPTION + *--------------------*/ + +static const lv_font_fmt_txt_glyph_dsc_t glyph_dsc[] = { + {.bitmap_index = 0, .adv_w = 0, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0} /* id = 0 reserved */, + {.bitmap_index = 0, .adv_w = 71, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 0, .adv_w = 71, .box_w = 3, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 18, .adv_w = 91, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 7}, + {.bitmap_index = 31, .adv_w = 142, .box_w = 9, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 85, .adv_w = 142, .box_w = 9, .box_h = 16, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 157, .adv_w = 228, .box_w = 14, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 241, .adv_w = 171, .box_w = 11, .box_h = 13, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 313, .adv_w = 49, .box_w = 3, .box_h = 5, .ofs_x = 0, .ofs_y = 7}, + {.bitmap_index = 321, .adv_w = 85, .box_w = 5, .box_h = 15, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 359, .adv_w = 85, .box_w = 5, .box_h = 15, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 397, .adv_w = 100, .box_w = 6, .box_h = 6, .ofs_x = 0, .ofs_y = 6}, + {.bitmap_index = 415, .adv_w = 150, .box_w = 9, .box_h = 9, .ofs_x = 0, .ofs_y = 2}, + {.bitmap_index = 456, .adv_w = 71, .box_w = 2, .box_h = 5, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 461, .adv_w = 85, .box_w = 5, .box_h = 2, .ofs_x = 0, .ofs_y = 4}, + {.bitmap_index = 466, .adv_w = 71, .box_w = 3, .box_h = 2, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 469, .adv_w = 71, .box_w = 5, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 499, .adv_w = 142, .box_w = 9, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 553, .adv_w = 142, .box_w = 5, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 583, .adv_w = 142, .box_w = 9, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 637, .adv_w = 142, .box_w = 9, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 691, .adv_w = 142, .box_w = 9, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 745, .adv_w = 142, .box_w = 9, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 799, .adv_w = 142, .box_w = 9, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 853, .adv_w = 142, .box_w = 9, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 907, .adv_w = 142, .box_w = 9, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 961, .adv_w = 142, .box_w = 9, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1015, .adv_w = 71, .box_w = 3, .box_h = 9, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1029, .adv_w = 71, .box_w = 2, .box_h = 12, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 1041, .adv_w = 150, .box_w = 9, .box_h = 10, .ofs_x = 0, .ofs_y = 1}, + {.bitmap_index = 1086, .adv_w = 150, .box_w = 9, .box_h = 6, .ofs_x = 0, .ofs_y = 3}, + {.bitmap_index = 1113, .adv_w = 150, .box_w = 9, .box_h = 10, .ofs_x = 0, .ofs_y = 1}, + {.bitmap_index = 1158, .adv_w = 142, .box_w = 9, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1212, .adv_w = 260, .box_w = 16, .box_h = 15, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 1332, .adv_w = 171, .box_w = 12, .box_h = 12, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 1404, .adv_w = 171, .box_w = 9, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1458, .adv_w = 185, .box_w = 11, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1524, .adv_w = 185, .box_w = 10, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1584, .adv_w = 171, .box_w = 9, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1638, .adv_w = 157, .box_w = 9, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1692, .adv_w = 199, .box_w = 12, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1764, .adv_w = 185, .box_w = 10, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1824, .adv_w = 71, .box_w = 2, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1836, .adv_w = 128, .box_w = 7, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1878, .adv_w = 171, .box_w = 10, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1938, .adv_w = 142, .box_w = 8, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1986, .adv_w = 213, .box_w = 12, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2058, .adv_w = 185, .box_w = 10, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2118, .adv_w = 199, .box_w = 12, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2190, .adv_w = 171, .box_w = 9, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2244, .adv_w = 199, .box_w = 12, .box_h = 13, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 2322, .adv_w = 185, .box_w = 11, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2388, .adv_w = 171, .box_w = 10, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2448, .adv_w = 157, .box_w = 10, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2508, .adv_w = 185, .box_w = 10, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2568, .adv_w = 171, .box_w = 11, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2634, .adv_w = 242, .box_w = 15, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2724, .adv_w = 171, .box_w = 11, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2790, .adv_w = 171, .box_w = 11, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2856, .adv_w = 157, .box_w = 10, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2916, .adv_w = 71, .box_w = 4, .box_h = 15, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 2946, .adv_w = 71, .box_w = 5, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2976, .adv_w = 71, .box_w = 4, .box_h = 15, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 3006, .adv_w = 120, .box_w = 8, .box_h = 7, .ofs_x = 0, .ofs_y = 6}, + {.bitmap_index = 3034, .adv_w = 142, .box_w = 10, .box_h = 2, .ofs_x = -1, .ofs_y = -4}, + {.bitmap_index = 3044, .adv_w = 85, .box_w = 4, .box_h = 3, .ofs_x = 0, .ofs_y = 10}, + {.bitmap_index = 3050, .adv_w = 142, .box_w = 9, .box_h = 9, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3091, .adv_w = 142, .box_w = 8, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3139, .adv_w = 128, .box_w = 8, .box_h = 9, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3175, .adv_w = 142, .box_w = 8, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3223, .adv_w = 142, .box_w = 9, .box_h = 9, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3264, .adv_w = 71, .box_w = 5, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3294, .adv_w = 142, .box_w = 8, .box_h = 12, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 3342, .adv_w = 142, .box_w = 7, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3384, .adv_w = 57, .box_w = 2, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3396, .adv_w = 57, .box_w = 4, .box_h = 15, .ofs_x = -1, .ofs_y = -3}, + {.bitmap_index = 3426, .adv_w = 128, .box_w = 7, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3468, .adv_w = 57, .box_w = 2, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3480, .adv_w = 213, .box_w = 12, .box_h = 9, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3534, .adv_w = 142, .box_w = 7, .box_h = 9, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3566, .adv_w = 142, .box_w = 9, .box_h = 9, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3607, .adv_w = 142, .box_w = 8, .box_h = 12, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 3655, .adv_w = 142, .box_w = 8, .box_h = 12, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 3703, .adv_w = 85, .box_w = 5, .box_h = 9, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3726, .adv_w = 128, .box_w = 8, .box_h = 9, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3762, .adv_w = 71, .box_w = 5, .box_h = 13, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3795, .adv_w = 142, .box_w = 7, .box_h = 9, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3827, .adv_w = 128, .box_w = 8, .box_h = 9, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3863, .adv_w = 185, .box_w = 12, .box_h = 9, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3917, .adv_w = 128, .box_w = 8, .box_h = 9, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3953, .adv_w = 128, .box_w = 8, .box_h = 12, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 4001, .adv_w = 128, .box_w = 8, .box_h = 9, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4037, .adv_w = 85, .box_w = 5, .box_h = 15, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 4075, .adv_w = 67, .box_w = 2, .box_h = 15, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 4090, .adv_w = 85, .box_w = 5, .box_h = 15, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 4128, .adv_w = 150, .box_w = 9, .box_h = 4, .ofs_x = 0, .ofs_y = 4}, + {.bitmap_index = 4146, .adv_w = 71, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4146, .adv_w = 142, .box_w = 9, .box_h = 13, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 4205, .adv_w = 142, .box_w = 9, .box_h = 9, .ofs_x = 0, .ofs_y = 2}, + {.bitmap_index = 4246, .adv_w = 142, .box_w = 9, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4300, .adv_w = 67, .box_w = 2, .box_h = 15, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 4315, .adv_w = 142, .box_w = 9, .box_h = 15, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 4383, .adv_w = 85, .box_w = 5, .box_h = 2, .ofs_x = 0, .ofs_y = 11}, + {.bitmap_index = 4388, .adv_w = 189, .box_w = 12, .box_h = 13, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 4466, .adv_w = 96, .box_w = 6, .box_h = 6, .ofs_x = 0, .ofs_y = 6}, + {.bitmap_index = 4484, .adv_w = 142, .box_w = 7, .box_h = 8, .ofs_x = 1, .ofs_y = 1}, + {.bitmap_index = 4512, .adv_w = 150, .box_w = 9, .box_h = 5, .ofs_x = 0, .ofs_y = 4}, + {.bitmap_index = 4535, .adv_w = 85, .box_w = 5, .box_h = 2, .ofs_x = 0, .ofs_y = 4}, + {.bitmap_index = 4540, .adv_w = 189, .box_w = 12, .box_h = 13, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 4618, .adv_w = 102, .box_w = 5, .box_h = 5, .ofs_x = 1, .ofs_y = 8}, + {.bitmap_index = 4631, .adv_w = 150, .box_w = 9, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4681, .adv_w = 85, .box_w = 6, .box_h = 6, .ofs_x = 0, .ofs_y = 6}, + {.bitmap_index = 4699, .adv_w = 85, .box_w = 6, .box_h = 6, .ofs_x = 0, .ofs_y = 6}, + {.bitmap_index = 4717, .adv_w = 142, .box_w = 7, .box_h = 12, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 4759, .adv_w = 138, .box_w = 10, .box_h = 15, .ofs_x = -1, .ofs_y = -3}, + {.bitmap_index = 4834, .adv_w = 72, .box_w = 3, .box_h = 2, .ofs_x = 1, .ofs_y = 5}, + {.bitmap_index = 4837, .adv_w = 142, .box_w = 7, .box_h = 8, .ofs_x = 1, .ofs_y = 1}, + {.bitmap_index = 4865, .adv_w = 214, .box_w = 14, .box_h = 14, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 4963, .adv_w = 85, .box_w = 4, .box_h = 3, .ofs_x = 1, .ofs_y = 10}, + {.bitmap_index = 4969, .adv_w = 171, .box_w = 12, .box_h = 12, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 5041, .adv_w = 201, .box_w = 13, .box_h = 12, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 5119, .adv_w = 215, .box_w = 13, .box_h = 12, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 5197, .adv_w = 98, .box_w = 6, .box_h = 12, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 5233, .adv_w = 198, .box_w = 13, .box_h = 12, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 5311, .adv_w = 219, .box_w = 15, .box_h = 12, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 5401, .adv_w = 193, .box_w = 13, .box_h = 12, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 5479, .adv_w = 57, .box_w = 7, .box_h = 12, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 5521, .adv_w = 171, .box_w = 12, .box_h = 12, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 5593, .adv_w = 171, .box_w = 9, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 5647, .adv_w = 141, .box_w = 8, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 5695, .adv_w = 171, .box_w = 12, .box_h = 12, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 5767, .adv_w = 171, .box_w = 9, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 5821, .adv_w = 157, .box_w = 10, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5881, .adv_w = 185, .box_w = 10, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 5941, .adv_w = 199, .box_w = 12, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6013, .adv_w = 71, .box_w = 2, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 6025, .adv_w = 171, .box_w = 10, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 6085, .adv_w = 171, .box_w = 11, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6151, .adv_w = 213, .box_w = 12, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 6223, .adv_w = 185, .box_w = 10, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 6283, .adv_w = 166, .box_w = 10, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6343, .adv_w = 199, .box_w = 12, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6415, .adv_w = 185, .box_w = 10, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 6475, .adv_w = 171, .box_w = 9, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 6529, .adv_w = 158, .box_w = 9, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 6583, .adv_w = 157, .box_w = 10, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6643, .adv_w = 171, .box_w = 11, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6709, .adv_w = 204, .box_w = 13, .box_h = 13, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 6794, .adv_w = 171, .box_w = 11, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6860, .adv_w = 214, .box_w = 12, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 6932, .adv_w = 191, .box_w = 12, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7004, .adv_w = 71, .box_w = 6, .box_h = 15, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 7049, .adv_w = 171, .box_w = 11, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7132, .adv_w = 148, .box_w = 9, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7186, .adv_w = 114, .box_w = 7, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7228, .adv_w = 142, .box_w = 7, .box_h = 15, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 7281, .adv_w = 57, .box_w = 4, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7305, .adv_w = 140, .box_w = 7, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 7347, .adv_w = 148, .box_w = 9, .box_h = 9, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7388, .adv_w = 147, .box_w = 8, .box_h = 15, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 7448, .adv_w = 128, .box_w = 8, .box_h = 12, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 7496, .adv_w = 143, .box_w = 9, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7550, .adv_w = 114, .box_w = 7, .box_h = 9, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7582, .adv_w = 113, .box_w = 7, .box_h = 15, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 7635, .adv_w = 142, .box_w = 7, .box_h = 12, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 7677, .adv_w = 142, .box_w = 9, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7731, .adv_w = 57, .box_w = 2, .box_h = 9, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 7740, .adv_w = 128, .box_w = 7, .box_h = 9, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 7772, .adv_w = 128, .box_w = 8, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7820, .adv_w = 142, .box_w = 7, .box_h = 12, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 7862, .adv_w = 128, .box_w = 8, .box_h = 9, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7898, .adv_w = 115, .box_w = 7, .box_h = 15, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 7951, .adv_w = 142, .box_w = 9, .box_h = 9, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7992, .adv_w = 177, .box_w = 11, .box_h = 9, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 8042, .adv_w = 146, .box_w = 8, .box_h = 12, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 8090, .adv_w = 123, .box_w = 8, .box_h = 12, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 8138, .adv_w = 158, .box_w = 10, .box_h = 9, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 8183, .adv_w = 101, .box_w = 6, .box_h = 9, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 8210, .adv_w = 140, .box_w = 7, .box_h = 9, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 8242, .adv_w = 166, .box_w = 10, .box_h = 12, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 8302, .adv_w = 134, .box_w = 9, .box_h = 12, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 8356, .adv_w = 183, .box_w = 11, .box_h = 12, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 8422, .adv_w = 200, .box_w = 12, .box_h = 9, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 8476, .adv_w = 57, .box_w = 5, .box_h = 12, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 8506, .adv_w = 140, .box_w = 7, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 8548, .adv_w = 142, .box_w = 9, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 8602, .adv_w = 140, .box_w = 7, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 8644, .adv_w = 200, .box_w = 12, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 8716, .adv_w = 85, .box_w = 7, .box_h = 2, .ofs_x = -1, .ofs_y = 10} +}; + +/*--------------------- + * CHARACTER MAPPING + *--------------------*/ + +static const uint8_t glyph_id_ofs_list_1[] = { + 0, 0, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 0, + 13, 14, 15, 16, 0, 17, 18, 19, + 0, 0, 0, 20, 0, 21 +}; + +static const uint8_t glyph_id_ofs_list_2[] = { + 0, 0, 1, 0, 2, 3, 4, 0, + 5 +}; + +/*Collect the unicode lists and glyph_id offsets*/ +static const lv_font_fmt_txt_cmap_t cmaps[] = +{ + { + .range_start = 32, .range_length = 95, .glyph_id_start = 1, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 160, .range_length = 30, .glyph_id_start = 96, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_1, .list_length = 30, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 900, .range_length = 9, .glyph_id_start = 118, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_2, .list_length = 9, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 910, .range_length = 20, .glyph_id_start = 124, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 931, .range_length = 44, .glyph_id_start = 144, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 1012, .range_length = 1, .glyph_id_start = 188, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + } +}; + + + +/*-------------------- + * ALL CUSTOM DATA + *--------------------*/ + +#if LVGL_VERSION_MAJOR == 8 +/*Store all the custom data of the font*/ +static lv_font_fmt_txt_glyph_cache_t cache; +#endif + +#if LVGL_VERSION_MAJOR >= 8 +static const lv_font_fmt_txt_dsc_t font_dsc = { +#else +static lv_font_fmt_txt_dsc_t font_dsc = { +#endif + .glyph_bitmap = glyph_bitmap, + .glyph_dsc = glyph_dsc, + .cmaps = cmaps, + .kern_dsc = NULL, + .kern_scale = 0, + .cmap_num = 6, + .bpp = 4, + .kern_classes = 0, + .bitmap_format = 0, +#if LVGL_VERSION_MAJOR == 8 + .cache = &cache +#endif + +}; + +extern const lv_font_t lv_font_montserrat_16; + + +/*----------------- + * PUBLIC FONT + *----------------*/ + +/*Initialize a public general font descriptor*/ +#if LVGL_VERSION_MAJOR >= 8 +const lv_font_t lv_font_arial_16 = { +#else +lv_font_t lv_font_arial_16 = { +#endif + .get_glyph_dsc = lv_font_get_glyph_dsc_fmt_txt, /*Function pointer to get glyph's data*/ + .get_glyph_bitmap = lv_font_get_bitmap_fmt_txt, /*Function pointer to get glyph's bitmap*/ + .line_height = 19, /*The maximum line height required by the font*/ + .base_line = 4, /*Baseline measured from the bottom of the line*/ +#if !(LVGL_VERSION_MAJOR == 6 && LVGL_VERSION_MINOR == 0) + .subpx = LV_FONT_SUBPX_NONE, +#endif +#if LV_VERSION_CHECK(7, 4, 0) || LVGL_VERSION_MAJOR >= 8 + .underline_position = -2, + .underline_thickness = 1, +#endif + //.static_bitmap = 0, + .dsc = &font_dsc, /*The custom font data. Will be accessed by `get_glyph_bitmap/dsc` */ +#if LV_VERSION_CHECK(8, 2, 0) || LVGL_VERSION_MAJOR >= 9 + .fallback = &lv_font_montserrat_16, +#endif + .user_data = NULL, +}; + + + +#endif /*#if LV_FONT_ARIAL_16*/ diff --git a/src/fonts/lv_font_arial_18.c b/src/fonts/lv_font_arial_18.c new file mode 100644 index 0000000000..c8ed871efa --- /dev/null +++ b/src/fonts/lv_font_arial_18.c @@ -0,0 +1,2201 @@ +/******************************************************************************* + * Size: 18 px + * Bpp: 4 + * Opts: --bpp 4 --size 18 --no-compress --stride 1 --align 1 --font Arial Greek Regular.ttf --range 32-127,160-255,880-1023 --format lvgl -o lv_font_arial_18.c + ******************************************************************************/ + +#ifdef __has_include + #if __has_include("lvgl.h") + #ifndef LV_LVGL_H_INCLUDE_SIMPLE + #define LV_LVGL_H_INCLUDE_SIMPLE + #endif + #endif +#endif + +#ifdef LV_LVGL_H_INCLUDE_SIMPLE + #include "lvgl.h" +#else + #include "lvgl/lvgl.h" +#endif + + + +#ifndef LV_FONT_ARIAL_18 +#define LV_FONT_ARIAL_18 1 +#endif + +#if LV_FONT_ARIAL_18 + +/*----------------- + * BITMAPS + *----------------*/ + +/*Store the image of the glyphs*/ +static LV_ATTRIBUTE_LARGE_CONST const uint8_t glyph_bitmap[] = { + /* U+0020 " " */ + + /* U+0021 "!" */ + 0x7f, 0x77, 0xf7, 0x7f, 0x77, 0xf7, 0x6f, 0x65, + 0xf5, 0x4f, 0x42, 0xf3, 0x1f, 0x20, 0xf1, 0x2, + 0x0, 0x0, 0x5e, 0x56, 0xf6, + + /* U+0022 "\"" */ + 0x2f, 0xa4, 0xf9, 0x2f, 0xa4, 0xf9, 0x1f, 0x93, + 0xf8, 0xf, 0x60, 0xf5, 0x9, 0x30, 0xb2, + + /* U+0023 "#" */ + 0x0, 0x7, 0xd0, 0x5, 0xf0, 0x0, 0xa, 0xa0, + 0x8, 0xc0, 0x0, 0xd, 0x70, 0xb, 0x90, 0x0, + 0xf, 0x40, 0xe, 0x60, 0xcf, 0xff, 0xff, 0xff, + 0xfd, 0x46, 0xae, 0x66, 0x9f, 0x64, 0x0, 0x9b, + 0x0, 0x8d, 0x0, 0x0, 0xc8, 0x0, 0xba, 0x0, + 0x11, 0xf6, 0x11, 0xe8, 0x11, 0xcf, 0xff, 0xff, + 0xff, 0xfd, 0x38, 0xf4, 0x47, 0xf4, 0x43, 0x8, + 0xc0, 0x7, 0xd0, 0x0, 0xc, 0x90, 0xa, 0xa0, + 0x0, 0xf, 0x50, 0xd, 0x70, 0x0, + + /* U+0024 "$" */ + 0x0, 0x0, 0x88, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xe6, 0x0, 0x6, 0xf9, 0x99, 0xbf, 0x40, 0xd, + 0xc0, 0x77, 0xf, 0xb0, 0xf, 0x90, 0x77, 0x4, + 0x20, 0xe, 0xd0, 0x77, 0x0, 0x0, 0x7, 0xfb, + 0xa7, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xa3, 0x0, + 0x0, 0x0, 0x9d, 0xff, 0x50, 0x0, 0x0, 0x77, + 0x1e, 0xe0, 0x2, 0x10, 0x77, 0x8, 0xf2, 0x3f, + 0x70, 0x77, 0x7, 0xf2, 0xf, 0xd0, 0x77, 0xd, + 0xe0, 0x7, 0xfc, 0xbb, 0xcf, 0x60, 0x0, 0x5c, + 0xff, 0xd5, 0x0, 0x0, 0x0, 0x77, 0x0, 0x0, + 0x0, 0x0, 0x33, 0x0, 0x0, + + /* U+0025 "%" */ + 0x9, 0xed, 0x40, 0x0, 0x5, 0xe0, 0x0, 0x7e, + 0x47, 0xf2, 0x0, 0xd, 0x60, 0x0, 0xc9, 0x0, + 0xe7, 0x0, 0x5e, 0x0, 0x0, 0xe7, 0x0, 0xc8, + 0x0, 0xd6, 0x0, 0x0, 0xc8, 0x0, 0xe7, 0x6, + 0xe0, 0x0, 0x0, 0x8d, 0x14, 0xf3, 0xd, 0x60, + 0x0, 0x0, 0x1b, 0xff, 0x70, 0x6e, 0x0, 0x0, + 0x0, 0x0, 0x10, 0x0, 0xd6, 0x5, 0xde, 0x80, + 0x0, 0x0, 0x6, 0xe0, 0x2f, 0x74, 0xe7, 0x0, + 0x0, 0xd, 0x60, 0x7e, 0x0, 0x8c, 0x0, 0x0, + 0x6e, 0x0, 0x8d, 0x0, 0x7e, 0x0, 0x0, 0xe6, + 0x0, 0x7e, 0x0, 0x9c, 0x0, 0x6, 0xe0, 0x0, + 0x2f, 0x63, 0xe7, 0x0, 0xe, 0x60, 0x0, 0x5, + 0xde, 0x80, + + /* U+0026 "&" */ + 0x0, 0x3, 0xcf, 0xd4, 0x0, 0x0, 0x0, 0x2f, + 0xc6, 0xcf, 0x30, 0x0, 0x0, 0x8f, 0x10, 0x2f, + 0x80, 0x0, 0x0, 0x8f, 0x30, 0x2f, 0x70, 0x0, + 0x0, 0x2f, 0xc2, 0xcf, 0x10, 0x0, 0x0, 0x8, + 0xff, 0xe3, 0x0, 0x0, 0x0, 0x2c, 0xff, 0x60, + 0x0, 0x0, 0x3, 0xfe, 0x5e, 0xf2, 0x7, 0x30, + 0xd, 0xf2, 0x4, 0xfd, 0x5f, 0x70, 0x2f, 0x90, + 0x0, 0x7f, 0xff, 0x20, 0x2f, 0x90, 0x0, 0xb, + 0xfb, 0x0, 0xe, 0xf1, 0x0, 0x2d, 0xff, 0x40, + 0x5, 0xfe, 0x89, 0xff, 0x6f, 0xf4, 0x0, 0x5c, + 0xfe, 0xa2, 0x3, 0xd1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0027 "'" */ + 0x3f, 0xa3, 0xfa, 0x2f, 0x90, 0xf6, 0xa, 0x30, + + /* U+0028 "(" */ + 0x0, 0x2f, 0x10, 0xb, 0x90, 0x4, 0xf1, 0x0, + 0xbb, 0x0, 0x2f, 0x60, 0x6, 0xf2, 0x0, 0xae, + 0x0, 0xc, 0xd0, 0x0, 0xdc, 0x0, 0xd, 0xc0, + 0x0, 0xcd, 0x0, 0xa, 0xf0, 0x0, 0x6f, 0x20, + 0x2, 0xf6, 0x0, 0xb, 0xb0, 0x0, 0x4f, 0x10, + 0x0, 0xb9, 0x0, 0x2, 0xf1, + + /* U+0029 ")" */ + 0x1e, 0x20, 0x0, 0x9b, 0x0, 0x1, 0xf4, 0x0, + 0xb, 0xb0, 0x0, 0x6f, 0x10, 0x2, 0xf6, 0x0, + 0xe, 0xa0, 0x0, 0xdc, 0x0, 0xc, 0xd0, 0x0, + 0xcd, 0x0, 0xd, 0xc0, 0x0, 0xfa, 0x0, 0x2f, + 0x60, 0x6, 0xf1, 0x0, 0xbb, 0x0, 0x1f, 0x30, + 0x9, 0xb0, 0x1, 0xe2, 0x0, + + /* U+002A "*" */ + 0x0, 0x1f, 0x10, 0x0, 0x61, 0xf1, 0x60, 0x3e, + 0xef, 0xee, 0x30, 0xa, 0xf9, 0x0, 0x5, 0xf4, + 0xf5, 0x0, 0x26, 0x6, 0x20, + + /* U+002B "+" */ + 0x0, 0x7, 0xe0, 0x0, 0x0, 0x0, 0x7f, 0x0, + 0x0, 0x0, 0x7, 0xf0, 0x0, 0x0, 0x0, 0x7f, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0x88, 0x88, + 0xcf, 0x88, 0x84, 0x0, 0x7, 0xf0, 0x0, 0x0, + 0x0, 0x7f, 0x0, 0x0, 0x0, 0x7, 0xf0, 0x0, + 0x0, + + /* U+002C "," */ + 0x6e, 0x57, 0xf5, 0x9, 0x41, 0xd1, 0x34, 0x0, + + /* U+002D "-" */ + 0x4a, 0xaa, 0xa4, 0x6f, 0xff, 0xf7, + + /* U+002E "." */ + 0x5e, 0x56, 0xf6, + + /* U+002F "/" */ + 0x0, 0x6, 0xd0, 0x0, 0xa9, 0x0, 0xe, 0x50, + 0x3, 0xf1, 0x0, 0x7c, 0x0, 0xb, 0x80, 0x0, + 0xf4, 0x0, 0x4f, 0x0, 0x8, 0xb0, 0x0, 0xc7, + 0x0, 0x1f, 0x30, 0x5, 0xe0, 0x0, 0x9a, 0x0, + 0xd, 0x60, 0x0, + + /* U+0030 "0" */ + 0x0, 0x2b, 0xff, 0xa1, 0x0, 0x1, 0xee, 0x77, + 0xed, 0x0, 0x8, 0xf2, 0x0, 0x3f, 0x70, 0xd, + 0xc0, 0x0, 0xc, 0xc0, 0xf, 0x90, 0x0, 0x9, + 0xf0, 0x2f, 0x70, 0x0, 0x7, 0xf1, 0x3f, 0x60, + 0x0, 0x7, 0xf2, 0x3f, 0x60, 0x0, 0x7, 0xf2, + 0x2f, 0x70, 0x0, 0x7, 0xf1, 0xf, 0x90, 0x0, + 0x9, 0xf0, 0xd, 0xc0, 0x0, 0xc, 0xc0, 0x8, + 0xf3, 0x0, 0x3f, 0x70, 0x1, 0xee, 0x77, 0xed, + 0x0, 0x0, 0x2b, 0xff, 0xa1, 0x0, + + /* U+0031 "1" */ + 0x0, 0x9, 0xb0, 0x5, 0xfb, 0x7, 0xff, 0xbc, + 0xfa, 0xdb, 0xd5, 0xd, 0xb0, 0x0, 0xdb, 0x0, + 0xd, 0xb0, 0x0, 0xdb, 0x0, 0xd, 0xb0, 0x0, + 0xdb, 0x0, 0xd, 0xb0, 0x0, 0xdb, 0x0, 0xd, + 0xb0, 0x0, 0xdb, + + /* U+0032 "2" */ + 0x0, 0x4b, 0xff, 0xc4, 0x0, 0x3, 0xfd, 0x77, + 0xdf, 0x40, 0xc, 0xe0, 0x0, 0xe, 0xc0, 0xf, + 0x90, 0x0, 0x9, 0xf0, 0x1, 0x10, 0x0, 0xb, + 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xb0, 0x0, 0x0, + 0x0, 0xcf, 0x30, 0x0, 0x0, 0xb, 0xf7, 0x0, + 0x0, 0x0, 0xbf, 0x80, 0x0, 0x0, 0xc, 0xf7, + 0x0, 0x0, 0x0, 0xcf, 0x60, 0x0, 0x0, 0x9, + 0xf7, 0x0, 0x0, 0x0, 0x2f, 0xf9, 0x99, 0x99, + 0x90, 0x6f, 0xff, 0xff, 0xff, 0xf1, + + /* U+0033 "3" */ + 0x0, 0x3b, 0xfe, 0xa1, 0x0, 0x2, 0xfd, 0x68, + 0xfd, 0x0, 0xb, 0xe1, 0x0, 0x5f, 0x60, 0xb, + 0x90, 0x0, 0x1f, 0x90, 0x0, 0x0, 0x0, 0x4f, + 0x70, 0x0, 0x0, 0x4, 0xee, 0x10, 0x0, 0x0, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x44, 0xbf, 0x60, + 0x0, 0x0, 0x0, 0xd, 0xf0, 0x0, 0x0, 0x0, + 0x8, 0xf3, 0x1e, 0x80, 0x0, 0x9, 0xf2, 0xd, + 0xe0, 0x0, 0x1e, 0xd0, 0x4, 0xfd, 0x67, 0xef, + 0x40, 0x0, 0x4c, 0xff, 0xb2, 0x0, + + /* U+0034 "4" */ + 0x0, 0x0, 0x2, 0xf7, 0x0, 0x0, 0x0, 0xc, + 0xf7, 0x0, 0x0, 0x0, 0x6f, 0xf7, 0x0, 0x0, + 0x1, 0xe9, 0xf7, 0x0, 0x0, 0xa, 0xd2, 0xf7, + 0x0, 0x0, 0x4f, 0x42, 0xf7, 0x0, 0x0, 0xda, + 0x2, 0xf7, 0x0, 0x8, 0xf1, 0x2, 0xf7, 0x0, + 0x2f, 0x60, 0x2, 0xf7, 0x0, 0xaf, 0x88, 0x89, + 0xfb, 0x81, 0xbf, 0xff, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x2, 0xf7, 0x0, 0x0, 0x0, 0x2, 0xf7, + 0x0, 0x0, 0x0, 0x2, 0xf7, 0x0, + + /* U+0035 "5" */ + 0x0, 0xcf, 0xff, 0xff, 0xb0, 0x0, 0xfc, 0x99, + 0x99, 0x60, 0x1, 0xf6, 0x0, 0x0, 0x0, 0x4, + 0xf4, 0x0, 0x0, 0x0, 0x7, 0xf1, 0x1, 0x0, + 0x0, 0x9, 0xf9, 0xff, 0xe7, 0x0, 0xc, 0xfb, + 0x67, 0xdf, 0x70, 0x7, 0x70, 0x0, 0xe, 0xf0, + 0x0, 0x0, 0x0, 0x7, 0xf4, 0x0, 0x0, 0x0, + 0x6, 0xf4, 0x1c, 0x70, 0x0, 0x8, 0xf2, 0xe, + 0xe0, 0x0, 0x1f, 0xc0, 0x4, 0xfd, 0x77, 0xef, + 0x30, 0x0, 0x4b, 0xef, 0xb3, 0x0, + + /* U+0036 "6" */ + 0x0, 0x8, 0xef, 0xc4, 0x0, 0x0, 0xcf, 0x86, + 0xcf, 0x40, 0x6, 0xf4, 0x0, 0xe, 0xc0, 0xc, + 0xd0, 0x0, 0x5, 0x60, 0xf, 0x80, 0x1, 0x0, + 0x0, 0x2f, 0x78, 0xff, 0xe7, 0x0, 0x3f, 0xde, + 0x76, 0xcf, 0x60, 0x3f, 0xf2, 0x0, 0xd, 0xe0, + 0x3f, 0xb0, 0x0, 0x7, 0xf2, 0x1f, 0x90, 0x0, + 0x6, 0xf3, 0xe, 0xc0, 0x0, 0x8, 0xf1, 0x8, + 0xf4, 0x0, 0xe, 0xc0, 0x1, 0xdf, 0x87, 0xdf, + 0x30, 0x0, 0x19, 0xef, 0xc4, 0x0, + + /* U+0037 "7" */ + 0x1f, 0xff, 0xff, 0xff, 0xf3, 0x19, 0x99, 0x99, + 0x9f, 0xe1, 0x0, 0x0, 0x0, 0x6f, 0x50, 0x0, + 0x0, 0x1, 0xea, 0x0, 0x0, 0x0, 0xa, 0xf2, + 0x0, 0x0, 0x0, 0x1f, 0xa0, 0x0, 0x0, 0x0, + 0x8f, 0x20, 0x0, 0x0, 0x0, 0xec, 0x0, 0x0, + 0x0, 0x4, 0xf6, 0x0, 0x0, 0x0, 0x9, 0xf1, + 0x0, 0x0, 0x0, 0xd, 0xd0, 0x0, 0x0, 0x0, + 0xf, 0xa0, 0x0, 0x0, 0x0, 0x3f, 0x70, 0x0, + 0x0, 0x0, 0x4f, 0x50, 0x0, 0x0, + + /* U+0038 "8" */ + 0x0, 0x2b, 0xff, 0xb2, 0x0, 0x2, 0xee, 0x77, + 0xee, 0x10, 0x8, 0xf3, 0x0, 0x3f, 0x80, 0xb, + 0xf0, 0x0, 0xf, 0xb0, 0x8, 0xf1, 0x0, 0x1f, + 0x90, 0x1, 0xdb, 0x22, 0xbf, 0x20, 0x0, 0x6f, + 0xff, 0xf5, 0x0, 0x7, 0xfb, 0x55, 0xcf, 0x50, + 0xf, 0xc0, 0x0, 0xc, 0xe0, 0x3f, 0x70, 0x0, + 0x7, 0xf3, 0x2f, 0x70, 0x0, 0x7, 0xf3, 0xe, + 0xd0, 0x0, 0xd, 0xe0, 0x5, 0xfd, 0x77, 0xdf, + 0x50, 0x0, 0x4b, 0xff, 0xc4, 0x0, + + /* U+0039 "9" */ + 0x0, 0x3c, 0xfe, 0x91, 0x0, 0x3, 0xfe, 0x77, + 0xed, 0x0, 0xc, 0xf2, 0x0, 0x2f, 0x80, 0x1f, + 0xa0, 0x0, 0xa, 0xe0, 0x3f, 0x70, 0x0, 0x8, + 0xf1, 0x2f, 0x80, 0x0, 0x9, 0xf3, 0xe, 0xd0, + 0x0, 0xe, 0xf3, 0x7, 0xfb, 0x33, 0xbe, 0xf3, + 0x0, 0x9f, 0xff, 0xb7, 0xf2, 0x0, 0x2, 0x42, + 0x7, 0xf0, 0x4, 0x30, 0x0, 0xc, 0xc0, 0xc, + 0xd0, 0x0, 0x4f, 0x60, 0x4, 0xfb, 0x68, 0xfc, + 0x0, 0x0, 0x5c, 0xfe, 0x80, 0x0, + + /* U+003A ":" */ + 0x6f, 0x65, 0xe5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5e, 0x56, 0xf6, + + /* U+003B ";" */ + 0x7f, 0x56, 0xe5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6e, 0x57, 0xf5, 0x9, + 0x41, 0xd1, 0x34, 0x0, + + /* U+003C "<" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xc8, 0x0, 0x0, 0x6d, 0xfd, 0x40, 0x28, 0xff, + 0xb4, 0x0, 0xaf, 0xf9, 0x20, 0x0, 0xf, 0xf6, + 0x0, 0x0, 0x0, 0x5c, 0xfe, 0x71, 0x0, 0x0, + 0x3, 0xaf, 0xf9, 0x20, 0x0, 0x0, 0x29, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x76, + + /* U+003D "=" */ + 0xff, 0xff, 0xff, 0xff, 0x88, 0x88, 0x88, 0x88, + 0x84, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0x88, 0x88, + 0x88, 0x88, 0x84, + + /* U+003E ">" */ + 0x0, 0x0, 0x0, 0x0, 0xf, 0x82, 0x0, 0x0, + 0x0, 0xaf, 0xfa, 0x30, 0x0, 0x0, 0x18, 0xef, + 0xc5, 0x0, 0x0, 0x0, 0x5c, 0xfe, 0x40, 0x0, + 0x0, 0x2c, 0xf8, 0x0, 0x4, 0xbf, 0xf8, 0x10, + 0x6d, 0xfe, 0x70, 0x0, 0xef, 0xc5, 0x0, 0x0, + 0xb, 0x40, 0x0, 0x0, 0x0, + + /* U+003F "?" */ + 0x0, 0x3b, 0xff, 0xc4, 0x0, 0x3, 0xfe, 0x77, + 0xdf, 0x50, 0xc, 0xf1, 0x0, 0x1e, 0xe0, 0xf, + 0x90, 0x0, 0x8, 0xf1, 0x0, 0x10, 0x0, 0x9, + 0xf0, 0x0, 0x0, 0x0, 0x3f, 0xa0, 0x0, 0x0, + 0x3, 0xfd, 0x10, 0x0, 0x0, 0x1e, 0xe1, 0x0, + 0x0, 0x0, 0x9f, 0x20, 0x0, 0x0, 0x0, 0xcc, + 0x0, 0x0, 0x0, 0x0, 0x87, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x0, + 0x0, 0x0, 0x0, 0xee, 0x0, 0x0, + + /* U+0040 "@" */ + 0x0, 0x0, 0x6, 0xbe, 0xfe, 0xc8, 0x10, 0x0, + 0x0, 0x0, 0x5e, 0xfa, 0x75, 0x69, 0xef, 0x60, + 0x0, 0x0, 0x5f, 0xa1, 0x0, 0x0, 0x0, 0x8f, + 0x70, 0x0, 0x2f, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0x30, 0xb, 0xc0, 0x1, 0xaf, 0xe7, 0x3f, + 0x50, 0xca, 0x2, 0xf3, 0x1, 0xde, 0x77, 0xec, + 0xf2, 0x5, 0xf0, 0x8c, 0x0, 0xaf, 0x20, 0x4, + 0xff, 0x0, 0x2f, 0x2c, 0x80, 0x2f, 0x90, 0x0, + 0xf, 0xc0, 0x1, 0xf3, 0xe6, 0x7, 0xf3, 0x0, + 0x0, 0xf8, 0x0, 0x3f, 0x1f, 0x50, 0x9f, 0x0, + 0x0, 0x2f, 0x50, 0x8, 0xe0, 0xe7, 0x8, 0xf1, + 0x0, 0x9, 0xf2, 0x1, 0xe7, 0xc, 0x90, 0x5f, + 0x60, 0x4, 0xff, 0x0, 0xcd, 0x0, 0x8e, 0x0, + 0xdf, 0xaa, 0xfd, 0xfa, 0xee, 0x20, 0x2, 0xf6, + 0x2, 0xcf, 0xc3, 0x5e, 0xea, 0x10, 0x31, 0x9, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0x40, + 0xc, 0xf7, 0x0, 0x0, 0x0, 0x1, 0xaf, 0x60, + 0x0, 0x9, 0xff, 0xa7, 0x66, 0x8b, 0xfe, 0x40, + 0x0, 0x0, 0x2, 0x8c, 0xef, 0xfe, 0xb6, 0x0, + 0x0, + + /* U+0041 "A" */ + 0x0, 0x0, 0x3, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0xe, 0x9e, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0x5a, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xaf, 0x15, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0xfc, 0x0, 0xfd, + 0x0, 0x0, 0x0, 0x5, 0xf7, 0x0, 0xbf, 0x30, + 0x0, 0x0, 0xb, 0xf2, 0x0, 0x5f, 0x90, 0x0, + 0x0, 0x1f, 0xd2, 0x22, 0x3f, 0xf0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0xcf, + 0x55, 0x55, 0x57, 0xfb, 0x0, 0x2, 0xfc, 0x0, + 0x0, 0x0, 0xef, 0x10, 0x7, 0xf5, 0x0, 0x0, + 0x0, 0x8f, 0x70, 0xd, 0xf0, 0x0, 0x0, 0x0, + 0x1f, 0xd0, + + /* U+0042 "B" */ + 0xaf, 0xff, 0xff, 0xd7, 0x0, 0xa, 0xf9, 0x99, + 0xad, 0xfb, 0x0, 0xaf, 0x0, 0x0, 0xa, 0xf4, + 0xa, 0xf0, 0x0, 0x0, 0x4f, 0x60, 0xaf, 0x0, + 0x0, 0x5, 0xf4, 0xa, 0xf0, 0x0, 0x4, 0xdd, + 0x0, 0xaf, 0xff, 0xff, 0xfe, 0x20, 0xa, 0xf9, + 0x99, 0xac, 0xfe, 0x20, 0xaf, 0x0, 0x0, 0x4, + 0xfb, 0xa, 0xf0, 0x0, 0x0, 0xc, 0xf0, 0xaf, + 0x0, 0x0, 0x0, 0xcf, 0xa, 0xf0, 0x0, 0x0, + 0x3f, 0xc0, 0xaf, 0x99, 0x99, 0xcf, 0xf4, 0xa, + 0xff, 0xff, 0xfe, 0xa3, 0x0, + + /* U+0043 "C" */ + 0x0, 0x0, 0x7c, 0xff, 0xc6, 0x0, 0x0, 0x2, + 0xdf, 0xc9, 0x9d, 0xfa, 0x0, 0x0, 0xdf, 0x50, + 0x0, 0xa, 0xf7, 0x0, 0x6f, 0x70, 0x0, 0x0, + 0xe, 0xe0, 0xc, 0xf1, 0x0, 0x0, 0x0, 0x31, + 0x0, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0x10, 0x0, 0x0, 0x8, + 0xb2, 0x6, 0xf7, 0x0, 0x0, 0x0, 0xee, 0x0, + 0xd, 0xf4, 0x0, 0x0, 0xaf, 0x70, 0x0, 0x2e, + 0xfc, 0x9a, 0xef, 0xa0, 0x0, 0x0, 0x18, 0xdf, + 0xfc, 0x60, 0x0, + + /* U+0044 "D" */ + 0x9f, 0xff, 0xff, 0xea, 0x30, 0x0, 0x9f, 0xa9, + 0x9a, 0xcf, 0xf4, 0x0, 0x9f, 0x20, 0x0, 0x3, + 0xef, 0x10, 0x9f, 0x20, 0x0, 0x0, 0x6f, 0x70, + 0x9f, 0x20, 0x0, 0x0, 0xf, 0xc0, 0x9f, 0x20, + 0x0, 0x0, 0xc, 0xf0, 0x9f, 0x20, 0x0, 0x0, + 0xb, 0xf0, 0x9f, 0x20, 0x0, 0x0, 0xb, 0xf0, + 0x9f, 0x20, 0x0, 0x0, 0xd, 0xe0, 0x9f, 0x20, + 0x0, 0x0, 0xf, 0xb0, 0x9f, 0x20, 0x0, 0x0, + 0x6f, 0x60, 0x9f, 0x20, 0x0, 0x3, 0xee, 0x10, + 0x9f, 0xa9, 0x9a, 0xcf, 0xf4, 0x0, 0x9f, 0xff, + 0xff, 0xd9, 0x20, 0x0, + + /* U+0045 "E" */ + 0x9f, 0xff, 0xff, 0xff, 0xfb, 0x9, 0xfa, 0x99, + 0x99, 0x99, 0x60, 0x9f, 0x20, 0x0, 0x0, 0x0, + 0x9, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x9f, 0x20, + 0x0, 0x0, 0x0, 0x9, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xa9, 0x99, 0x99, 0x92, 0x9, 0xff, + 0xff, 0xff, 0xff, 0x40, 0x9f, 0x20, 0x0, 0x0, + 0x0, 0x9, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0x20, 0x0, 0x0, 0x0, 0x9, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xa9, 0x99, 0x99, 0x99, 0x9, + 0xff, 0xff, 0xff, 0xff, 0xf0, + + /* U+0046 "F" */ + 0x9f, 0xff, 0xff, 0xff, 0xf2, 0x9f, 0xa9, 0x99, + 0x99, 0x91, 0x9f, 0x20, 0x0, 0x0, 0x0, 0x9f, + 0x20, 0x0, 0x0, 0x0, 0x9f, 0x20, 0x0, 0x0, + 0x0, 0x9f, 0x20, 0x0, 0x0, 0x0, 0x9f, 0xa9, + 0x99, 0x99, 0x10, 0x9f, 0xff, 0xff, 0xff, 0x30, + 0x9f, 0x20, 0x0, 0x0, 0x0, 0x9f, 0x20, 0x0, + 0x0, 0x0, 0x9f, 0x20, 0x0, 0x0, 0x0, 0x9f, + 0x20, 0x0, 0x0, 0x0, 0x9f, 0x20, 0x0, 0x0, + 0x0, 0x9f, 0x20, 0x0, 0x0, 0x0, + + /* U+0047 "G" */ + 0x0, 0x0, 0x6b, 0xef, 0xea, 0x30, 0x0, 0x1, + 0xcf, 0xd9, 0x9b, 0xff, 0x50, 0x0, 0xbf, 0x70, + 0x0, 0x2, 0xef, 0x10, 0x5f, 0x90, 0x0, 0x0, + 0x4, 0xf7, 0xb, 0xf1, 0x0, 0x0, 0x0, 0x6, + 0x10, 0xed, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xfb, 0x0, + 0x0, 0x9f, 0xff, 0xfd, 0xf, 0xd0, 0x0, 0x5, + 0x99, 0x9e, 0xd0, 0xbf, 0x10, 0x0, 0x0, 0x0, + 0xdd, 0x5, 0xf9, 0x0, 0x0, 0x0, 0xd, 0xd0, + 0xb, 0xf8, 0x0, 0x0, 0x8, 0xfd, 0x0, 0x1c, + 0xff, 0xba, 0xbf, 0xfd, 0x20, 0x0, 0x5, 0xbe, + 0xfe, 0xb5, 0x0, + + /* U+0048 "H" */ + 0x9f, 0x20, 0x0, 0x0, 0x2f, 0x89, 0xf2, 0x0, + 0x0, 0x2, 0xf8, 0x9f, 0x20, 0x0, 0x0, 0x2f, + 0x89, 0xf2, 0x0, 0x0, 0x2, 0xf8, 0x9f, 0x20, + 0x0, 0x0, 0x2f, 0x89, 0xf2, 0x0, 0x0, 0x2, + 0xf8, 0x9f, 0xff, 0xff, 0xff, 0xff, 0x89, 0xfa, + 0x99, 0x99, 0x9a, 0xf8, 0x9f, 0x20, 0x0, 0x0, + 0x2f, 0x89, 0xf2, 0x0, 0x0, 0x2, 0xf8, 0x9f, + 0x20, 0x0, 0x0, 0x2f, 0x89, 0xf2, 0x0, 0x0, + 0x2, 0xf8, 0x9f, 0x20, 0x0, 0x0, 0x2f, 0x89, + 0xf2, 0x0, 0x0, 0x2, 0xf8, + + /* U+0049 "I" */ + 0x5f, 0x55, 0xf5, 0x5f, 0x55, 0xf5, 0x5f, 0x55, + 0xf5, 0x5f, 0x55, 0xf5, 0x5f, 0x55, 0xf5, 0x5f, + 0x55, 0xf5, 0x5f, 0x55, 0xf5, + + /* U+004A "J" */ + 0x0, 0x0, 0x1, 0xf9, 0x0, 0x0, 0x1, 0xf9, + 0x0, 0x0, 0x1, 0xf9, 0x0, 0x0, 0x1, 0xf9, + 0x0, 0x0, 0x1, 0xf9, 0x0, 0x0, 0x1, 0xf9, + 0x0, 0x0, 0x1, 0xf9, 0x0, 0x0, 0x1, 0xf9, + 0x0, 0x0, 0x1, 0xf9, 0x14, 0x0, 0x1, 0xf9, + 0x6f, 0x20, 0x3, 0xf8, 0x4f, 0x70, 0x7, 0xf5, + 0xd, 0xfb, 0xbf, 0xe0, 0x2, 0xbf, 0xea, 0x20, + + /* U+004B "K" */ + 0xaf, 0x0, 0x0, 0x2, 0xef, 0x4a, 0xf0, 0x0, + 0x1, 0xdf, 0x50, 0xaf, 0x0, 0x0, 0xcf, 0x50, + 0xa, 0xf0, 0x0, 0xcf, 0x60, 0x0, 0xaf, 0x0, + 0xbf, 0x70, 0x0, 0xa, 0xf0, 0xaf, 0x90, 0x0, + 0x0, 0xaf, 0x9f, 0xfd, 0x0, 0x0, 0xa, 0xff, + 0x97, 0xf9, 0x0, 0x0, 0xaf, 0xa0, 0xc, 0xf4, + 0x0, 0xa, 0xf0, 0x0, 0x3f, 0xe0, 0x0, 0xaf, + 0x0, 0x0, 0x8f, 0x90, 0xa, 0xf0, 0x0, 0x0, + 0xdf, 0x40, 0xaf, 0x0, 0x0, 0x3, 0xfe, 0x1a, + 0xf0, 0x0, 0x0, 0x9, 0xfa, + + /* U+004C "L" */ + 0xaf, 0x10, 0x0, 0x0, 0xa, 0xf1, 0x0, 0x0, + 0x0, 0xaf, 0x10, 0x0, 0x0, 0xa, 0xf1, 0x0, + 0x0, 0x0, 0xaf, 0x10, 0x0, 0x0, 0xa, 0xf1, + 0x0, 0x0, 0x0, 0xaf, 0x10, 0x0, 0x0, 0xa, + 0xf1, 0x0, 0x0, 0x0, 0xaf, 0x10, 0x0, 0x0, + 0xa, 0xf1, 0x0, 0x0, 0x0, 0xaf, 0x10, 0x0, + 0x0, 0xa, 0xf1, 0x0, 0x0, 0x0, 0xaf, 0x99, + 0x99, 0x99, 0x3a, 0xff, 0xff, 0xff, 0xf6, + + /* U+004D "M" */ + 0xaf, 0xf1, 0x0, 0x0, 0x0, 0xcf, 0xaa, 0xff, + 0x60, 0x0, 0x0, 0x1f, 0xfa, 0xaf, 0xdb, 0x0, + 0x0, 0x7, 0xef, 0xaa, 0xf8, 0xf0, 0x0, 0x0, + 0xc9, 0xfa, 0xaf, 0x3f, 0x40, 0x0, 0x1f, 0x4f, + 0xaa, 0xf0, 0xe9, 0x0, 0x6, 0xf0, 0xfa, 0xaf, + 0x9, 0xe0, 0x0, 0xba, 0xf, 0xaa, 0xf0, 0x4f, + 0x30, 0xf, 0x50, 0xfa, 0xaf, 0x0, 0xf8, 0x5, + 0xf0, 0xf, 0xaa, 0xf0, 0xb, 0xd0, 0xab, 0x0, + 0xfa, 0xaf, 0x0, 0x6f, 0x2f, 0x60, 0xf, 0xaa, + 0xf0, 0x1, 0xfb, 0xf1, 0x0, 0xfa, 0xaf, 0x0, + 0xc, 0xfb, 0x0, 0xf, 0xaa, 0xf0, 0x0, 0x7f, + 0x60, 0x0, 0xfa, + + /* U+004E "N" */ + 0x9f, 0x70, 0x0, 0x0, 0x1f, 0x99, 0xff, 0x20, + 0x0, 0x1, 0xf9, 0x9f, 0xfb, 0x0, 0x0, 0x1f, + 0x99, 0xfb, 0xf5, 0x0, 0x1, 0xf9, 0x9f, 0x2e, + 0xe0, 0x0, 0x1f, 0x99, 0xf1, 0x6f, 0x80, 0x1, + 0xf9, 0x9f, 0x10, 0xcf, 0x30, 0x1f, 0x99, 0xf1, + 0x2, 0xfc, 0x1, 0xf9, 0x9f, 0x10, 0x8, 0xf6, + 0x1f, 0x99, 0xf1, 0x0, 0xe, 0xe2, 0xf9, 0x9f, + 0x10, 0x0, 0x5f, 0xbf, 0x99, 0xf1, 0x0, 0x0, + 0xbf, 0xf9, 0x9f, 0x10, 0x0, 0x2, 0xff, 0x99, + 0xf1, 0x0, 0x0, 0x7, 0xf9, + + /* U+004F "O" */ + 0x0, 0x0, 0x7c, 0xff, 0xc7, 0x0, 0x0, 0x0, + 0x1d, 0xfd, 0x99, 0xdf, 0xd1, 0x0, 0x0, 0xdf, + 0x50, 0x0, 0x6, 0xfd, 0x0, 0x6, 0xf7, 0x0, + 0x0, 0x0, 0x7f, 0x60, 0xc, 0xf0, 0x0, 0x0, + 0x0, 0xf, 0xd0, 0xf, 0xc0, 0x0, 0x0, 0x0, + 0xb, 0xf0, 0x1f, 0xa0, 0x0, 0x0, 0x0, 0xa, + 0xf2, 0x1f, 0xa0, 0x0, 0x0, 0x0, 0xa, 0xf2, + 0xf, 0xb0, 0x0, 0x0, 0x0, 0xb, 0xf0, 0xc, + 0xf0, 0x0, 0x0, 0x0, 0xf, 0xd0, 0x6, 0xf7, + 0x0, 0x0, 0x0, 0x7f, 0x70, 0x0, 0xdf, 0x50, + 0x0, 0x5, 0xfd, 0x0, 0x0, 0x1d, 0xfc, 0x99, + 0xcf, 0xd1, 0x0, 0x0, 0x0, 0x7d, 0xff, 0xc7, + 0x0, 0x0, + + /* U+0050 "P" */ + 0x9f, 0xff, 0xff, 0xec, 0x50, 0x9, 0xfa, 0x99, + 0x9a, 0xef, 0x60, 0x9f, 0x10, 0x0, 0x2, 0xfe, + 0x9, 0xf1, 0x0, 0x0, 0xa, 0xf2, 0x9f, 0x10, + 0x0, 0x0, 0x9f, 0x39, 0xf1, 0x0, 0x0, 0xc, + 0xf0, 0x9f, 0x10, 0x0, 0x29, 0xfa, 0x9, 0xff, + 0xff, 0xff, 0xfd, 0x10, 0x9f, 0xa9, 0x99, 0x84, + 0x0, 0x9, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0x10, 0x0, 0x0, 0x0, 0x9, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0x10, 0x0, 0x0, 0x0, 0x9, + 0xf1, 0x0, 0x0, 0x0, 0x0, + + /* U+0051 "Q" */ + 0x0, 0x0, 0x7c, 0xfe, 0xc6, 0x0, 0x0, 0x0, + 0x1d, 0xfd, 0x99, 0xcf, 0xd1, 0x0, 0x0, 0xdf, + 0x50, 0x0, 0x5, 0xfd, 0x0, 0x6, 0xf7, 0x0, + 0x0, 0x0, 0x7f, 0x60, 0xc, 0xf0, 0x0, 0x0, + 0x0, 0xf, 0xc0, 0xf, 0xb0, 0x0, 0x0, 0x0, + 0xb, 0xf0, 0x1f, 0xa0, 0x0, 0x0, 0x0, 0xa, + 0xf1, 0x1f, 0xa0, 0x0, 0x0, 0x0, 0xa, 0xf2, + 0xf, 0xb0, 0x0, 0x0, 0x0, 0xb, 0xf0, 0xc, + 0xf0, 0x0, 0x0, 0x0, 0xf, 0xc0, 0x6, 0xf7, + 0x0, 0x9, 0x81, 0x7f, 0x60, 0x0, 0xcf, 0x50, + 0x7, 0xee, 0xfd, 0x0, 0x0, 0x1d, 0xfc, 0x99, + 0xdf, 0xf9, 0x0, 0x0, 0x0, 0x7d, 0xfe, 0xc6, + 0x6f, 0xd2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x91, + + /* U+0052 "R" */ + 0x9f, 0xff, 0xff, 0xfe, 0xa2, 0x0, 0x9f, 0x98, + 0x88, 0x8b, 0xfe, 0x10, 0x9f, 0x20, 0x0, 0x0, + 0x8f, 0x70, 0x9f, 0x20, 0x0, 0x0, 0x1f, 0xb0, + 0x9f, 0x20, 0x0, 0x0, 0x1f, 0xa0, 0x9f, 0x20, + 0x0, 0x0, 0x9f, 0x60, 0x9f, 0x98, 0x88, 0x9d, + 0xfc, 0x0, 0x9f, 0xff, 0xff, 0xfc, 0x70, 0x0, + 0x9f, 0x20, 0x4, 0xed, 0x20, 0x0, 0x9f, 0x20, + 0x0, 0x3f, 0xe1, 0x0, 0x9f, 0x20, 0x0, 0x7, + 0xfa, 0x0, 0x9f, 0x20, 0x0, 0x0, 0xdf, 0x40, + 0x9f, 0x20, 0x0, 0x0, 0x4f, 0xd0, 0x9f, 0x20, + 0x0, 0x0, 0xa, 0xf7, + + /* U+0053 "S" */ + 0x0, 0x8, 0xdf, 0xfc, 0x60, 0x0, 0x0, 0xdf, + 0xca, 0xae, 0xfb, 0x0, 0x7, 0xf6, 0x0, 0x0, + 0xaf, 0x50, 0xa, 0xf0, 0x0, 0x0, 0x1f, 0x90, + 0x9, 0xf4, 0x0, 0x0, 0x2, 0x0, 0x2, 0xff, + 0xa5, 0x10, 0x0, 0x0, 0x0, 0x4d, 0xff, 0xfd, + 0x71, 0x0, 0x0, 0x0, 0x37, 0xcf, 0xfe, 0x20, + 0x0, 0x0, 0x0, 0x1, 0x8f, 0xb0, 0x1a, 0x50, + 0x0, 0x0, 0xb, 0xf0, 0xf, 0xc0, 0x0, 0x0, + 0xa, 0xf0, 0xa, 0xf8, 0x0, 0x0, 0x4f, 0xb0, + 0x1, 0xdf, 0xeb, 0xac, 0xfe, 0x20, 0x0, 0x7, + 0xcf, 0xfe, 0x91, 0x0, + + /* U+0054 "T" */ + 0x9f, 0xff, 0xff, 0xff, 0xff, 0x95, 0x99, 0x9b, + 0xfb, 0x99, 0x95, 0x0, 0x0, 0x6f, 0x50, 0x0, + 0x0, 0x0, 0x6, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0x50, 0x0, 0x0, 0x0, 0x6, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0x50, 0x0, 0x0, 0x0, + 0x6, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x6f, 0x50, + 0x0, 0x0, 0x0, 0x6, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0x50, 0x0, 0x0, 0x0, 0x6, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0x50, 0x0, 0x0, + 0x0, 0x6, 0xf5, 0x0, 0x0, + + /* U+0055 "U" */ + 0x9f, 0x20, 0x0, 0x0, 0x2f, 0x99, 0xf2, 0x0, + 0x0, 0x2, 0xf9, 0x9f, 0x20, 0x0, 0x0, 0x2f, + 0x99, 0xf2, 0x0, 0x0, 0x2, 0xf9, 0x9f, 0x20, + 0x0, 0x0, 0x2f, 0x99, 0xf2, 0x0, 0x0, 0x2, + 0xf9, 0x9f, 0x20, 0x0, 0x0, 0x2f, 0x99, 0xf2, + 0x0, 0x0, 0x2, 0xf8, 0x8f, 0x20, 0x0, 0x0, + 0x2f, 0x87, 0xf3, 0x0, 0x0, 0x3, 0xf7, 0x4f, + 0x70, 0x0, 0x0, 0x7f, 0x40, 0xfe, 0x20, 0x0, + 0x2e, 0xe0, 0x6, 0xff, 0xba, 0xbf, 0xf5, 0x0, + 0x4, 0xbe, 0xfe, 0xa3, 0x0, + + /* U+0056 "V" */ + 0xbf, 0x10, 0x0, 0x0, 0x0, 0xfb, 0x5f, 0x60, + 0x0, 0x0, 0x6, 0xf5, 0xf, 0xc0, 0x0, 0x0, + 0xb, 0xf0, 0xa, 0xf1, 0x0, 0x0, 0x1f, 0x90, + 0x4, 0xf6, 0x0, 0x0, 0x6f, 0x40, 0x0, 0xeb, + 0x0, 0x0, 0xbe, 0x0, 0x0, 0x9f, 0x10, 0x1, + 0xf8, 0x0, 0x0, 0x3f, 0x60, 0x6, 0xf2, 0x0, + 0x0, 0xe, 0xb0, 0xc, 0xc0, 0x0, 0x0, 0x8, + 0xf1, 0x1f, 0x70, 0x0, 0x0, 0x2, 0xf6, 0x7f, + 0x10, 0x0, 0x0, 0x0, 0xda, 0xcb, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xf0, 0x0, 0x0, + + /* U+0057 "W" */ + 0xbf, 0x0, 0x0, 0xa, 0xfa, 0x0, 0x0, 0x1f, + 0x97, 0xf4, 0x0, 0x0, 0xef, 0xe0, 0x0, 0x4, + 0xf5, 0x3f, 0x70, 0x0, 0x2f, 0x9f, 0x20, 0x0, + 0x8f, 0x10, 0xfa, 0x0, 0x7, 0xf2, 0xf7, 0x0, + 0xc, 0xd0, 0xb, 0xe0, 0x0, 0xbc, 0xd, 0xb0, + 0x0, 0xf9, 0x0, 0x7f, 0x10, 0xf, 0x80, 0x9f, + 0x0, 0x3f, 0x50, 0x3, 0xf5, 0x3, 0xf4, 0x5, + 0xf3, 0x6, 0xf1, 0x0, 0xf, 0x80, 0x7f, 0x0, + 0x1f, 0x70, 0xad, 0x0, 0x0, 0xbb, 0xb, 0xc0, + 0x0, 0xdb, 0xd, 0x90, 0x0, 0x7, 0xf0, 0xf7, + 0x0, 0x9, 0xe1, 0xf5, 0x0, 0x0, 0x3f, 0x5f, + 0x30, 0x0, 0x5f, 0x6f, 0x10, 0x0, 0x0, 0xfc, + 0xf0, 0x0, 0x1, 0xfc, 0xd0, 0x0, 0x0, 0xc, + 0xfb, 0x0, 0x0, 0xc, 0xf9, 0x0, 0x0, 0x0, + 0x8f, 0x70, 0x0, 0x0, 0x8f, 0x50, 0x0, + + /* U+0058 "X" */ + 0x1e, 0xe1, 0x0, 0x0, 0xa, 0xf3, 0x5, 0xfa, + 0x0, 0x0, 0x5f, 0x80, 0x0, 0xbf, 0x50, 0x1, + 0xfc, 0x0, 0x0, 0x1e, 0xe1, 0xc, 0xf2, 0x0, + 0x0, 0x6, 0xf9, 0x6f, 0x70, 0x0, 0x0, 0x0, + 0xbf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, + 0x0, 0x2, 0xfb, 0xcf, 0x40, 0x0, 0x0, 0xd, + 0xf2, 0x2f, 0xe0, 0x0, 0x0, 0x8f, 0x70, 0x7, + 0xf9, 0x0, 0x3, 0xfc, 0x0, 0x0, 0xdf, 0x30, + 0xd, 0xf2, 0x0, 0x0, 0x3f, 0xd0, 0x9f, 0x70, + 0x0, 0x0, 0x8, 0xf8, + + /* U+0059 "Y" */ + 0xaf, 0x60, 0x0, 0x0, 0x6, 0xf8, 0x1e, 0xe1, + 0x0, 0x0, 0x1f, 0xd0, 0x6, 0xfa, 0x0, 0x0, + 0xaf, 0x40, 0x0, 0xcf, 0x30, 0x3, 0xfa, 0x0, + 0x0, 0x3f, 0xc0, 0xd, 0xe1, 0x0, 0x0, 0x9, + 0xf6, 0x6f, 0x50, 0x0, 0x0, 0x0, 0xee, 0xeb, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xb0, 0x0, 0x0, + + /* U+005A "Z" */ + 0xe, 0xff, 0xff, 0xff, 0xff, 0x40, 0x89, 0x99, + 0x99, 0x9f, 0xf3, 0x0, 0x0, 0x0, 0x7, 0xfa, + 0x0, 0x0, 0x0, 0x3, 0xfd, 0x0, 0x0, 0x0, + 0x1, 0xef, 0x20, 0x0, 0x0, 0x0, 0xbf, 0x60, + 0x0, 0x0, 0x0, 0x6f, 0xa0, 0x0, 0x0, 0x0, + 0x2f, 0xe1, 0x0, 0x0, 0x0, 0xd, 0xf3, 0x0, + 0x0, 0x0, 0x9, 0xf7, 0x0, 0x0, 0x0, 0x5, + 0xfb, 0x0, 0x0, 0x0, 0x1, 0xee, 0x10, 0x0, + 0x0, 0x0, 0xaf, 0xc9, 0x99, 0x99, 0x99, 0x4a, + 0xff, 0xff, 0xff, 0xff, 0xf8, + + /* U+005B "[" */ + 0xcf, 0xfb, 0xcd, 0x64, 0xcc, 0x0, 0xcc, 0x0, + 0xcc, 0x0, 0xcc, 0x0, 0xcc, 0x0, 0xcc, 0x0, + 0xcc, 0x0, 0xcc, 0x0, 0xcc, 0x0, 0xcc, 0x0, + 0xcc, 0x0, 0xcc, 0x0, 0xcc, 0x0, 0xcc, 0x0, + 0xcd, 0x64, 0xcf, 0xfb, + + /* U+005C "\\" */ + 0xd6, 0x0, 0x9, 0xa0, 0x0, 0x5e, 0x0, 0x1, + 0xf3, 0x0, 0xc, 0x70, 0x0, 0x8b, 0x0, 0x4, + 0xf0, 0x0, 0xf, 0x40, 0x0, 0xb8, 0x0, 0x7, + 0xc0, 0x0, 0x3f, 0x10, 0x0, 0xe5, 0x0, 0xa, + 0x90, 0x0, 0x6d, + + /* U+005D "]" */ + 0xbf, 0xfd, 0x46, 0xdd, 0x0, 0xcd, 0x0, 0xcd, + 0x0, 0xcd, 0x0, 0xcd, 0x0, 0xcd, 0x0, 0xcd, + 0x0, 0xcd, 0x0, 0xcd, 0x0, 0xcd, 0x0, 0xcd, + 0x0, 0xcd, 0x0, 0xcd, 0x0, 0xcd, 0x0, 0xcd, + 0x46, 0xdd, 0xbf, 0xfd, + + /* U+005E "^" */ + 0x0, 0x4, 0x70, 0x0, 0x0, 0xd, 0xf4, 0x0, + 0x0, 0x4f, 0xdb, 0x0, 0x0, 0xac, 0x5f, 0x10, + 0x1, 0xf6, 0xf, 0x80, 0x7, 0xf1, 0x9, 0xe0, + 0xe, 0xa0, 0x3, 0xf5, 0x5f, 0x40, 0x0, 0xdc, + + /* U+005F "_" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xff, 0xff, 0xf1, 0x3, 0x33, 0x33, 0x33, + 0x33, 0x30, + + /* U+0060 "`" */ + 0x8, 0x80, 0x0, 0x6f, 0x60, 0x0, 0x9d, 0x0, + + /* U+0061 "a" */ + 0x0, 0x5c, 0xef, 0xd7, 0x0, 0x6, 0xfb, 0x67, + 0xcf, 0x70, 0xe, 0xc0, 0x0, 0xf, 0xb0, 0x0, + 0x10, 0x0, 0x1d, 0xc0, 0x0, 0x38, 0xbe, 0xff, + 0xc0, 0x9, 0xfd, 0x96, 0x3d, 0xc0, 0x2f, 0xa0, + 0x0, 0xe, 0xc0, 0x4f, 0x70, 0x0, 0x4f, 0xc0, + 0xe, 0xe6, 0x58, 0xff, 0xd0, 0x3, 0xbf, 0xec, + 0x58, 0xf1, + + /* U+0062 "b" */ + 0xcc, 0x0, 0x0, 0x0, 0xc, 0xc0, 0x0, 0x0, + 0x0, 0xcc, 0x0, 0x0, 0x0, 0xc, 0xc0, 0x0, + 0x0, 0x0, 0xcc, 0x5d, 0xfc, 0x40, 0xc, 0xff, + 0x86, 0xcf, 0x40, 0xcf, 0x50, 0x0, 0xed, 0xc, + 0xe0, 0x0, 0x8, 0xf2, 0xcb, 0x0, 0x0, 0x6f, + 0x4c, 0xa0, 0x0, 0x5, 0xf4, 0xcc, 0x0, 0x0, + 0x7f, 0x2c, 0xf2, 0x0, 0xd, 0xd0, 0xcf, 0xd4, + 0x3a, 0xf3, 0xc, 0xb7, 0xef, 0xc3, 0x0, + + /* U+0063 "c" */ + 0x0, 0x4c, 0xfe, 0xa2, 0x0, 0x4f, 0xd7, 0x7e, + 0xe1, 0xd, 0xe1, 0x0, 0x2f, 0x72, 0xf8, 0x0, + 0x0, 0x31, 0x4f, 0x60, 0x0, 0x0, 0x4, 0xf6, + 0x0, 0x0, 0x0, 0x2f, 0x80, 0x0, 0x9, 0x70, + 0xdd, 0x0, 0x2, 0xf8, 0x4, 0xfc, 0x77, 0xee, + 0x10, 0x4, 0xcf, 0xea, 0x10, + + /* U+0064 "d" */ + 0x0, 0x0, 0x0, 0xd, 0xc0, 0x0, 0x0, 0x0, + 0xdc, 0x0, 0x0, 0x0, 0xd, 0xc0, 0x0, 0x0, + 0x0, 0xdc, 0x0, 0x5d, 0xfd, 0x5d, 0xc0, 0x5f, + 0xc7, 0x8f, 0xfc, 0xe, 0xd0, 0x0, 0x5f, 0xc3, + 0xf7, 0x0, 0x0, 0xec, 0x5f, 0x50, 0x0, 0xc, + 0xc5, 0xf5, 0x0, 0x0, 0xcc, 0x2f, 0x70, 0x0, + 0xe, 0xc0, 0xde, 0x0, 0x5, 0xfc, 0x4, 0xfd, + 0x78, 0xfe, 0xc0, 0x4, 0xcf, 0xd6, 0xbc, + + /* U+0065 "e" */ + 0x0, 0x3b, 0xff, 0xb3, 0x0, 0x3, 0xfd, 0x76, + 0xcf, 0x40, 0xc, 0xe0, 0x0, 0xd, 0xd0, 0x2f, + 0x91, 0x11, 0x18, 0xf2, 0x4f, 0xff, 0xff, 0xff, + 0xf4, 0x4f, 0x84, 0x44, 0x44, 0x41, 0x2f, 0x90, + 0x0, 0x2, 0x40, 0xd, 0xf1, 0x0, 0xd, 0xe0, + 0x4, 0xfe, 0x76, 0xcf, 0x60, 0x0, 0x3b, 0xff, + 0xc4, 0x0, + + /* U+0066 "f" */ + 0x0, 0x8e, 0xf7, 0x4, 0xfd, 0x83, 0x7, 0xf2, + 0x0, 0x7, 0xf1, 0x0, 0xdf, 0xff, 0xf0, 0x4a, + 0xf5, 0x40, 0x7, 0xf1, 0x0, 0x7, 0xf1, 0x0, + 0x7, 0xf1, 0x0, 0x7, 0xf1, 0x0, 0x7, 0xf1, + 0x0, 0x7, 0xf1, 0x0, 0x7, 0xf1, 0x0, 0x7, + 0xf1, 0x0, + + /* U+0067 "g" */ + 0x0, 0x5d, 0xfd, 0x69, 0xd0, 0x5f, 0xc7, 0x8f, + 0xed, 0xe, 0xd0, 0x0, 0x4f, 0xd3, 0xf6, 0x0, + 0x0, 0xdd, 0x5f, 0x40, 0x0, 0xb, 0xd5, 0xf4, + 0x0, 0x0, 0xbd, 0x3f, 0x60, 0x0, 0xd, 0xd0, + 0xec, 0x0, 0x4, 0xfd, 0x5, 0xfc, 0x78, 0xff, + 0xd0, 0x5, 0xdf, 0xd6, 0xcd, 0x1, 0x0, 0x0, + 0xd, 0xb0, 0xf9, 0x0, 0x2, 0xf8, 0x9, 0xf9, + 0x68, 0xee, 0x10, 0x8, 0xdf, 0xea, 0x10, + + /* U+0068 "h" */ + 0xcc, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x0, 0x0, + 0xcc, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x0, 0x0, + 0xcc, 0x4c, 0xfd, 0x70, 0xcf, 0xf9, 0x7d, 0xf5, + 0xcf, 0x40, 0x1, 0xfb, 0xce, 0x0, 0x0, 0xcc, + 0xcc, 0x0, 0x0, 0xcd, 0xcc, 0x0, 0x0, 0xcd, + 0xcc, 0x0, 0x0, 0xcd, 0xcc, 0x0, 0x0, 0xcd, + 0xcc, 0x0, 0x0, 0xcd, 0xcc, 0x0, 0x0, 0xcd, + + /* U+0069 "i" */ + 0xcc, 0xbb, 0x0, 0x0, 0xcc, 0xcc, 0xcc, 0xcc, + 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, + + /* U+006A "j" */ + 0x0, 0xcc, 0x0, 0xbb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcc, 0x0, 0xcc, 0x0, 0xcc, 0x0, 0xcc, + 0x0, 0xcc, 0x0, 0xcc, 0x0, 0xcc, 0x0, 0xcc, + 0x0, 0xcc, 0x0, 0xcc, 0x0, 0xcc, 0x0, 0xdb, + 0x48, 0xf8, 0xaf, 0xb1, + + /* U+006B "k" */ + 0xcc, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x0, 0x0, + 0xcc, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x0, 0x0, + 0xcc, 0x0, 0x1d, 0xe2, 0xcc, 0x0, 0xce, 0x20, + 0xcc, 0xc, 0xf3, 0x0, 0xcc, 0xaf, 0x40, 0x0, + 0xcf, 0xff, 0x70, 0x0, 0xcf, 0x5b, 0xf2, 0x0, + 0xcc, 0x2, 0xfb, 0x0, 0xcc, 0x0, 0x8f, 0x50, + 0xcc, 0x0, 0xe, 0xe1, 0xcc, 0x0, 0x5, 0xf9, + + /* U+006C "l" */ + 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, + 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, + + /* U+006D "m" */ + 0xd9, 0x7d, 0xfd, 0x41, 0xaf, 0xe9, 0xd, 0xed, + 0x55, 0xef, 0xd8, 0x48, 0xf7, 0xdf, 0x20, 0x6, + 0xfa, 0x0, 0xe, 0xbd, 0xd0, 0x0, 0x4f, 0x60, + 0x0, 0xcd, 0xdc, 0x0, 0x4, 0xf5, 0x0, 0xc, + 0xdd, 0xc0, 0x0, 0x4f, 0x50, 0x0, 0xcd, 0xdc, + 0x0, 0x4, 0xf5, 0x0, 0xc, 0xdd, 0xc0, 0x0, + 0x4f, 0x50, 0x0, 0xcd, 0xdc, 0x0, 0x4, 0xf5, + 0x0, 0xc, 0xdd, 0xc0, 0x0, 0x4f, 0x50, 0x0, + 0xcd, + + /* U+006E "n" */ + 0xca, 0x6d, 0xfd, 0x70, 0xce, 0xe6, 0x4a, 0xf6, + 0xcf, 0x20, 0x0, 0xfb, 0xce, 0x0, 0x0, 0xdc, + 0xcc, 0x0, 0x0, 0xcd, 0xcc, 0x0, 0x0, 0xcd, + 0xcc, 0x0, 0x0, 0xcd, 0xcc, 0x0, 0x0, 0xcd, + 0xcc, 0x0, 0x0, 0xcd, 0xcc, 0x0, 0x0, 0xcd, + + /* U+006F "o" */ + 0x0, 0x3b, 0xff, 0xb3, 0x0, 0x4, 0xfd, 0x77, + 0xdf, 0x40, 0xe, 0xe1, 0x0, 0x1e, 0xe0, 0x3f, + 0x70, 0x0, 0x7, 0xf3, 0x5f, 0x50, 0x0, 0x4, + 0xf5, 0x5f, 0x50, 0x0, 0x5, 0xf5, 0x3f, 0x70, + 0x0, 0x7, 0xf3, 0xe, 0xe0, 0x0, 0xe, 0xe0, + 0x5, 0xfd, 0x77, 0xdf, 0x50, 0x0, 0x3b, 0xff, + 0xc4, 0x0, + + /* U+0070 "p" */ + 0xca, 0x7e, 0xfd, 0x50, 0xc, 0xfd, 0x32, 0x9f, + 0x50, 0xcf, 0x30, 0x0, 0xce, 0xc, 0xd0, 0x0, + 0x7, 0xf2, 0xcb, 0x0, 0x0, 0x5f, 0x4c, 0xb0, + 0x0, 0x5, 0xf4, 0xcd, 0x0, 0x0, 0x8f, 0x2c, + 0xf4, 0x0, 0x1e, 0xd0, 0xcf, 0xf8, 0x7d, 0xf4, + 0xc, 0xc6, 0xef, 0xc4, 0x0, 0xcc, 0x0, 0x0, + 0x0, 0xc, 0xc0, 0x0, 0x0, 0x0, 0xcc, 0x0, + 0x0, 0x0, 0xc, 0xc0, 0x0, 0x0, 0x0, + + /* U+0071 "q" */ + 0x0, 0x5d, 0xfd, 0x5a, 0xc0, 0x5f, 0xc6, 0x7f, + 0xec, 0xe, 0xd0, 0x0, 0x5f, 0xc2, 0xf7, 0x0, + 0x0, 0xec, 0x4f, 0x50, 0x0, 0xb, 0xc4, 0xf5, + 0x0, 0x0, 0xbc, 0x2f, 0x80, 0x0, 0xd, 0xc0, + 0xce, 0x10, 0x4, 0xfc, 0x3, 0xfd, 0x78, 0xff, + 0xc0, 0x3, 0xcf, 0xd6, 0xdc, 0x0, 0x0, 0x0, + 0xd, 0xc0, 0x0, 0x0, 0x0, 0xdc, 0x0, 0x0, + 0x0, 0xd, 0xc0, 0x0, 0x0, 0x0, 0xdc, + + /* U+0072 "r" */ + 0xd9, 0x8f, 0xe1, 0xde, 0xe8, 0xa0, 0xdf, 0x20, + 0x0, 0xdd, 0x0, 0x0, 0xdc, 0x0, 0x0, 0xdc, + 0x0, 0x0, 0xdc, 0x0, 0x0, 0xdc, 0x0, 0x0, + 0xdc, 0x0, 0x0, 0xdc, 0x0, 0x0, + + /* U+0073 "s" */ + 0x1, 0x9e, 0xfd, 0x70, 0x0, 0xce, 0x76, 0xaf, + 0x80, 0x2f, 0x60, 0x0, 0xaa, 0x1, 0xfd, 0x40, + 0x0, 0x0, 0x6, 0xff, 0xfb, 0x60, 0x0, 0x1, + 0x6b, 0xff, 0xc0, 0x3, 0x0, 0x0, 0x9f, 0x34, + 0xf6, 0x0, 0x6, 0xf3, 0xc, 0xf8, 0x68, 0xfc, + 0x0, 0x19, 0xdf, 0xd9, 0x10, + + /* U+0074 "t" */ + 0x0, 0x10, 0x0, 0x5f, 0x0, 0x8, 0xf0, 0x0, + 0x8f, 0x0, 0xbf, 0xff, 0x93, 0xaf, 0x52, 0x8, + 0xf0, 0x0, 0x8f, 0x0, 0x8, 0xf0, 0x0, 0x8f, + 0x0, 0x8, 0xf0, 0x0, 0x8f, 0x0, 0x7, 0xfb, + 0x60, 0x1c, 0xfb, + + /* U+0075 "u" */ + 0xdc, 0x0, 0x0, 0xdc, 0xdc, 0x0, 0x0, 0xdc, + 0xdc, 0x0, 0x0, 0xdc, 0xdc, 0x0, 0x0, 0xdc, + 0xdc, 0x0, 0x0, 0xdc, 0xdc, 0x0, 0x0, 0xdc, + 0xcc, 0x0, 0x0, 0xfc, 0xbf, 0x0, 0x5, 0xfc, + 0x6f, 0xd7, 0x9f, 0xdc, 0x7, 0xdf, 0xc4, 0xac, + + /* U+0076 "v" */ + 0x9f, 0x10, 0x0, 0xf, 0x93, 0xf6, 0x0, 0x5, + 0xf4, 0xe, 0xb0, 0x0, 0xbe, 0x0, 0x8f, 0x10, + 0xf, 0x80, 0x2, 0xf6, 0x5, 0xf3, 0x0, 0xd, + 0xb0, 0xbd, 0x0, 0x0, 0x7f, 0x2f, 0x70, 0x0, + 0x1, 0xfb, 0xf2, 0x0, 0x0, 0xc, 0xfc, 0x0, + 0x0, 0x0, 0x6f, 0x60, 0x0, + + /* U+0077 "w" */ + 0xcd, 0x0, 0x6, 0xf7, 0x0, 0xc, 0xb7, 0xf1, + 0x0, 0xaf, 0xb0, 0x1, 0xf7, 0x3f, 0x50, 0xe, + 0xef, 0x0, 0x5f, 0x20, 0xe9, 0x2, 0xf7, 0xf3, + 0x9, 0xd0, 0xa, 0xe0, 0x6e, 0xf, 0x70, 0xe9, + 0x0, 0x5f, 0x2a, 0xb0, 0xca, 0x2f, 0x40, 0x1, + 0xf6, 0xe7, 0x8, 0xe7, 0xf0, 0x0, 0xc, 0xcf, + 0x30, 0x4f, 0xdb, 0x0, 0x0, 0x7f, 0xf0, 0x0, + 0xff, 0x60, 0x0, 0x3, 0xfb, 0x0, 0xc, 0xf1, + 0x0, + + /* U+0078 "x" */ + 0x4f, 0xa0, 0x0, 0x9f, 0x40, 0xaf, 0x40, 0x4f, + 0x90, 0x1, 0xed, 0x1e, 0xd0, 0x0, 0x4, 0xfd, + 0xf3, 0x0, 0x0, 0xa, 0xf9, 0x0, 0x0, 0x0, + 0xdf, 0xd0, 0x0, 0x0, 0x9f, 0x7f, 0x90, 0x0, + 0x3f, 0x90, 0x9f, 0x30, 0xd, 0xe1, 0x1, 0xed, + 0x8, 0xf5, 0x0, 0x6, 0xf8, + + /* U+0079 "y" */ + 0x8f, 0x20, 0x0, 0xe, 0xa2, 0xf8, 0x0, 0x4, + 0xf5, 0xd, 0xd0, 0x0, 0x9f, 0x0, 0x7f, 0x20, + 0xe, 0x90, 0x1, 0xf8, 0x4, 0xf4, 0x0, 0xc, + 0xd0, 0xae, 0x0, 0x0, 0x6f, 0x2e, 0x90, 0x0, + 0x1, 0xfa, 0xf3, 0x0, 0x0, 0xb, 0xfd, 0x0, + 0x0, 0x0, 0x5f, 0x80, 0x0, 0x0, 0x5, 0xf2, + 0x0, 0x0, 0x0, 0xcc, 0x0, 0x0, 0xa, 0xcf, + 0x40, 0x0, 0x0, 0xde, 0x80, 0x0, 0x0, + + /* U+007A "z" */ + 0x4f, 0xff, 0xff, 0xff, 0x51, 0x55, 0x55, 0x5f, + 0xe1, 0x0, 0x0, 0xa, 0xf3, 0x0, 0x0, 0x7, + 0xf7, 0x0, 0x0, 0x4, 0xfa, 0x0, 0x0, 0x2, + 0xed, 0x0, 0x0, 0x0, 0xde, 0x20, 0x0, 0x0, + 0xbf, 0x40, 0x0, 0x0, 0x7f, 0xb6, 0x66, 0x66, + 0x4a, 0xff, 0xff, 0xff, 0xf9, + + /* U+007B "{" */ + 0x0, 0x9, 0xe9, 0x0, 0x5f, 0xa4, 0x0, 0x9e, + 0x0, 0x0, 0xad, 0x0, 0x0, 0xac, 0x0, 0x0, + 0xbc, 0x0, 0x0, 0xcb, 0x0, 0x1, 0xf8, 0x0, + 0x4d, 0xd1, 0x0, 0x7f, 0x70, 0x0, 0x5, 0xf5, + 0x0, 0x0, 0xda, 0x0, 0x0, 0xbc, 0x0, 0x0, + 0xac, 0x0, 0x0, 0xad, 0x0, 0x0, 0x9e, 0x0, + 0x0, 0x6f, 0x94, 0x0, 0x9, 0xf9, + + /* U+007C "|" */ + 0x5f, 0x5, 0xf0, 0x5f, 0x5, 0xf0, 0x5f, 0x5, + 0xf0, 0x5f, 0x5, 0xf0, 0x5f, 0x5, 0xf0, 0x5f, + 0x5, 0xf0, 0x5f, 0x5, 0xf0, 0x5f, 0x5, 0xf0, + 0x5f, 0x5, 0xf0, + + /* U+007D "}" */ + 0x9f, 0x90, 0x0, 0x49, 0xf5, 0x0, 0x0, 0xe9, + 0x0, 0x0, 0xda, 0x0, 0x0, 0xca, 0x0, 0x0, + 0xcb, 0x0, 0x0, 0xbc, 0x0, 0x0, 0x7f, 0x10, + 0x0, 0xd, 0xd4, 0x0, 0x7, 0xf8, 0x0, 0x5f, + 0x50, 0x0, 0xad, 0x0, 0x0, 0xcb, 0x0, 0x0, + 0xcb, 0x0, 0x0, 0xca, 0x0, 0x0, 0xe9, 0x0, + 0x49, 0xf6, 0x0, 0x9f, 0xa0, 0x0, + + /* U+007E "~" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xef, 0xb5, + 0x0, 0x17, 0x3f, 0xdd, 0xff, 0xfc, 0xfb, 0x35, + 0x0, 0x28, 0xdf, 0xc3, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+00A0 " " */ + + /* U+00A3 "£" */ + 0x0, 0x19, 0xdf, 0xc5, 0x0, 0x1, 0xef, 0x86, + 0xcf, 0x70, 0x7, 0xf4, 0x0, 0xc, 0xf0, 0xa, + 0xf0, 0x0, 0x3, 0x70, 0x8, 0xf2, 0x0, 0x0, + 0x0, 0x6, 0xf7, 0x11, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0x40, 0x0, 0x24, 0xde, 0x44, 0x10, 0x0, + 0x0, 0xbe, 0x0, 0x0, 0x0, 0x0, 0xdc, 0x0, + 0x0, 0x0, 0x2, 0xf6, 0x0, 0x0, 0x0, 0xb, + 0xc1, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfd, 0xba, + 0xd3, 0x5c, 0x65, 0x6a, 0xdf, 0xd4, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+00A4 "¤" */ + 0x4, 0x0, 0x0, 0x0, 0x40, 0x1f, 0xb9, 0xee, + 0x9b, 0xf1, 0x6, 0xff, 0x9a, 0xff, 0x60, 0x6, + 0xf3, 0x0, 0x4f, 0x60, 0xa, 0xc0, 0x0, 0xd, + 0xa0, 0xa, 0xc0, 0x0, 0xd, 0xa0, 0x6, 0xf4, + 0x0, 0x4f, 0x60, 0x6, 0xff, 0x99, 0xff, 0x60, + 0x1f, 0xb9, 0xee, 0x9b, 0xf1, 0x5, 0x0, 0x0, + 0x0, 0x50, + + /* U+00A5 "¥" */ + 0xbf, 0x10, 0x0, 0x2, 0xfb, 0x3f, 0x80, 0x0, + 0x9, 0xf3, 0xb, 0xf1, 0x0, 0x2f, 0xb0, 0x3, + 0xf8, 0x0, 0x9f, 0x30, 0x0, 0xaf, 0x11, 0xfa, + 0x0, 0x0, 0x2f, 0x89, 0xf2, 0x0, 0x1, 0x1a, + 0xef, 0xb1, 0x10, 0x6f, 0xff, 0xff, 0xff, 0xf7, + 0x14, 0x44, 0xdd, 0x44, 0x41, 0x0, 0x0, 0xcd, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xf7, 0x13, + 0x33, 0xdd, 0x33, 0x31, 0x0, 0x0, 0xcd, 0x0, + 0x0, 0x0, 0x0, 0xcd, 0x0, 0x0, + + /* U+00A6 "¦" */ + 0x5f, 0x5, 0xf0, 0x5f, 0x5, 0xf0, 0x5f, 0x5, + 0xf0, 0x5f, 0x1, 0x40, 0x0, 0x0, 0x0, 0x14, + 0x5, 0xf0, 0x5f, 0x5, 0xf0, 0x5f, 0x5, 0xf0, + 0x5f, 0x5, 0xf0, + + /* U+00A7 "§" */ + 0x0, 0x2b, 0xfe, 0xa1, 0x0, 0x0, 0xee, 0x78, + 0xfd, 0x0, 0x4, 0xf4, 0x0, 0x7f, 0x40, 0x5, + 0xf5, 0x0, 0x15, 0x10, 0x0, 0xdf, 0x40, 0x0, + 0x0, 0x1, 0xbf, 0xf9, 0x0, 0x0, 0xc, 0xc1, + 0xaf, 0xd3, 0x0, 0x2f, 0x30, 0x5, 0xef, 0x50, + 0x2f, 0x60, 0x0, 0x2e, 0xe0, 0xc, 0xf6, 0x0, + 0x6, 0xf2, 0x2, 0xdf, 0xb1, 0x7, 0xf1, 0x0, + 0x9, 0xff, 0x9f, 0x70, 0x0, 0x0, 0x4e, 0xf8, + 0x0, 0x0, 0x0, 0x1, 0xcf, 0x30, 0x4, 0x80, + 0x0, 0x1f, 0x90, 0x7, 0xf4, 0x0, 0x2f, 0x80, + 0x1, 0xef, 0x87, 0xdf, 0x20, 0x0, 0x2a, 0xef, + 0xb3, 0x0, + + /* U+00A8 "¨" */ + 0x6e, 0x22, 0xe6, 0x7f, 0x33, 0xf7, + + /* U+00A9 "©" */ + 0x0, 0x2, 0x8d, 0xfe, 0xa4, 0x0, 0x0, 0x0, + 0x6f, 0xa5, 0x34, 0x9f, 0x90, 0x0, 0x5, 0xf4, + 0x0, 0x0, 0x2, 0xda, 0x0, 0x1f, 0x40, 0x3b, + 0xec, 0x50, 0x1e, 0x50, 0x7a, 0x1, 0xf8, 0x24, + 0xe5, 0x7, 0xc0, 0xc4, 0x9, 0xb0, 0x0, 0x44, + 0x1, 0xf1, 0xe2, 0xb, 0x60, 0x0, 0x0, 0x0, + 0xe3, 0xf2, 0xc, 0x60, 0x0, 0x0, 0x0, 0xd3, + 0xd4, 0x9, 0x90, 0x0, 0x46, 0x0, 0xf1, 0x99, + 0x2, 0xf4, 0x2, 0xd7, 0x5, 0xd0, 0x2f, 0x20, + 0x6e, 0xff, 0x80, 0xd, 0x60, 0x8, 0xd1, 0x0, + 0x10, 0x0, 0xac, 0x0, 0x0, 0x9e, 0x71, 0x1, + 0x5d, 0xc1, 0x0, 0x0, 0x5, 0xcf, 0xff, 0xd7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x21, 0x0, 0x0, + 0x0, + + /* U+00AA "ª" */ + 0x7, 0xee, 0x6e, 0x54, 0xf4, 0x1d, 0xf1, 0x9b, + 0x0, 0x7e, 0xb, 0xa0, 0x5, 0xc0, 0x9b, 0x0, + 0x7e, 0x4, 0xf3, 0x2e, 0xf1, 0x7, 0xee, 0x6e, + 0x50, + + /* U+00AB "«" */ + 0x0, 0x6, 0x10, 0x44, 0x0, 0x9c, 0x3, 0xf3, + 0x4, 0xf4, 0xd, 0xb0, 0xd, 0xb0, 0x7f, 0x20, + 0x8f, 0x32, 0xf9, 0x0, 0x5f, 0x60, 0xdc, 0x0, + 0xa, 0xe0, 0x3f, 0x50, 0x1, 0xe7, 0x9, 0xe0, + 0x0, 0x5f, 0x10, 0xd7, + + /* U+00AC "¬" */ + 0xff, 0xff, 0xff, 0xff, 0x88, 0x88, 0x88, 0x88, + 0xf8, 0x0, 0x0, 0x0, 0xf, 0x80, 0x0, 0x0, + 0x0, 0xf8, 0x0, 0x0, 0x0, 0xf, 0x80, 0x0, + 0x0, 0x0, 0x84, + + /* U+00AD "­" */ + 0x4a, 0xaa, 0xa4, 0x6f, 0xff, 0xf7, + + /* U+00AE "®" */ + 0x0, 0x2, 0x8d, 0xfe, 0xa4, 0x0, 0x0, 0x0, + 0x6f, 0xa5, 0x34, 0x9f, 0x90, 0x0, 0x5, 0xf4, + 0x0, 0x0, 0x2, 0xda, 0x0, 0x1f, 0x40, 0x0, + 0x0, 0x0, 0x1e, 0x50, 0x7a, 0x4, 0xff, 0xfe, + 0x70, 0x7, 0xc0, 0xc4, 0x4, 0xe0, 0x4, 0xf2, + 0x1, 0xf1, 0xe2, 0x4, 0xe0, 0x3, 0xf1, 0x0, + 0xe3, 0xf2, 0x4, 0xfe, 0xfd, 0x50, 0x0, 0xd3, + 0xd4, 0x4, 0xe1, 0x7d, 0x10, 0x0, 0xf1, 0x99, + 0x4, 0xe0, 0xa, 0xa0, 0x5, 0xd0, 0x2f, 0x24, + 0xe0, 0x1, 0xf5, 0xd, 0x60, 0x8, 0xd2, 0x10, + 0x0, 0x11, 0xac, 0x0, 0x0, 0x9e, 0x71, 0x1, + 0x5d, 0xc1, 0x0, 0x0, 0x5, 0xcf, 0xff, 0xd7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x21, 0x0, 0x0, + 0x0, + + /* U+00B0 "°" */ + 0xa, 0xfc, 0x20, 0x99, 0x6, 0xc0, 0xc2, 0x0, + 0xf0, 0x98, 0x5, 0xc0, 0x1c, 0xfd, 0x30, 0x0, + 0x0, 0x0, + + /* U+00B1 "±" */ + 0x0, 0x7, 0xf0, 0x0, 0x0, 0x0, 0x7f, 0x0, + 0x0, 0x0, 0x7, 0xf0, 0x0, 0x8, 0x88, 0xcf, + 0x88, 0x84, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x7f, 0x0, 0x0, 0x0, 0x7, 0xf0, 0x0, 0x0, + 0x0, 0x7f, 0x0, 0x0, 0x0, 0x7, 0xe0, 0x0, + 0x8, 0x88, 0x88, 0x88, 0x84, 0xff, 0xff, 0xff, + 0xff, 0x80, + + /* U+00B2 "²" */ + 0x9, 0xef, 0xb1, 0x6f, 0x32, 0xe8, 0x1, 0x0, + 0xd8, 0x0, 0x1b, 0xe1, 0x2, 0xdd, 0x20, 0x1e, + 0xc1, 0x10, 0xaf, 0xff, 0xfb, + + /* U+00B3 "³" */ + 0x9, 0xfe, 0x90, 0x5e, 0x13, 0xf4, 0x0, 0x4, + 0xf3, 0x0, 0x7f, 0xa0, 0x0, 0x1, 0xd8, 0x7c, + 0x22, 0xe8, 0x1a, 0xff, 0xa1, + + /* U+00B5 "µ" */ + 0xcc, 0x0, 0x0, 0xcc, 0xcc, 0x0, 0x0, 0xcc, + 0xcc, 0x0, 0x0, 0xcc, 0xcc, 0x0, 0x0, 0xcc, + 0xcc, 0x0, 0x0, 0xcc, 0xcd, 0x0, 0x0, 0xcc, + 0xce, 0x0, 0x0, 0xec, 0xcf, 0x20, 0x2, 0xfc, + 0xcf, 0xd5, 0x6e, 0xfc, 0xcd, 0x8e, 0xf9, 0xac, + 0xcc, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x0, 0x0, + 0xcc, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x0, 0x0, + + /* U+00B6 "¶" */ + 0x0, 0x4c, 0xff, 0xff, 0xff, 0xb0, 0x4f, 0xff, + 0xf9, 0xaf, 0xc6, 0xc, 0xff, 0xff, 0x1, 0xf6, + 0x0, 0xff, 0xff, 0xf0, 0x1f, 0x60, 0xf, 0xff, + 0xff, 0x1, 0xf6, 0x0, 0xcf, 0xff, 0xf0, 0x1f, + 0x60, 0x3, 0xff, 0xff, 0x1, 0xf6, 0x0, 0x4, + 0xbe, 0xf0, 0x1f, 0x60, 0x0, 0x0, 0x7f, 0x1, + 0xf6, 0x0, 0x0, 0x7, 0xf0, 0x1f, 0x60, 0x0, + 0x0, 0x7f, 0x1, 0xf6, 0x0, 0x0, 0x7, 0xf0, + 0x1f, 0x60, 0x0, 0x0, 0x7f, 0x1, 0xf6, 0x0, + 0x0, 0x7, 0xf0, 0x1f, 0x60, 0x0, 0x0, 0x7f, + 0x1, 0xf6, 0x0, 0x0, 0x7, 0xf0, 0x1f, 0x60, + 0x0, 0x0, 0x7f, 0x1, 0xf6, 0x0, 0x0, 0x7, + 0xf0, 0x1f, 0x60, + + /* U+00B7 "·" */ + 0x5e, 0x66, 0xf6, + + /* U+00BB "»" */ + 0x44, 0x1, 0x60, 0x0, 0x3f, 0x30, 0xc9, 0x0, + 0xa, 0xd0, 0x4f, 0x40, 0x2, 0xf8, 0xb, 0xe0, + 0x0, 0x9f, 0x23, 0xf9, 0x0, 0xcd, 0x6, 0xf5, + 0x5, 0xf3, 0xe, 0xa0, 0xd, 0x90, 0x7e, 0x10, + 0x7d, 0x1, 0xf5, 0x0, + + /* U+00BD "½" */ + 0x0, 0x4f, 0x30, 0x0, 0x0, 0xa, 0xb0, 0x0, + 0x8f, 0xf3, 0x0, 0x0, 0x5, 0xe1, 0x0, 0xb, + 0x4f, 0x30, 0x0, 0x1, 0xe5, 0x0, 0x0, 0x1, + 0xf3, 0x0, 0x0, 0xbb, 0x0, 0x0, 0x0, 0x1f, + 0x30, 0x0, 0x5e, 0x10, 0x0, 0x0, 0x1, 0xf3, + 0x0, 0x1e, 0x50, 0x0, 0x0, 0x0, 0x1f, 0x20, + 0xb, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xe1, 0x8, 0xee, 0xa1, 0x0, 0x0, 0x2, 0xf4, + 0x6, 0xf4, 0x3e, 0x80, 0x0, 0x0, 0xc9, 0x0, + 0x1, 0x0, 0xd8, 0x0, 0x0, 0x7e, 0x0, 0x0, + 0x0, 0x9e, 0x10, 0x0, 0x2f, 0x40, 0x0, 0x0, + 0xbd, 0x20, 0x0, 0xc, 0x90, 0x0, 0x0, 0xcc, + 0x21, 0x10, 0x7, 0xd0, 0x0, 0x0, 0x8f, 0xff, + 0xfb, 0x0, 0x32, 0x0, 0x0, 0x3, 0x44, 0x44, + 0x20, + + /* U+0384 "΄" */ + 0x0, 0x88, 0x0, 0x5f, 0x60, 0xd, 0xa0, 0x0, + + /* U+0386 "Ά" */ + 0x0, 0x9f, 0x53, 0xfe, 0x0, 0x0, 0x0, 0x1, + 0xf9, 0x9, 0xef, 0x50, 0x0, 0x0, 0x3, 0x80, + 0xe, 0x8e, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0x59, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xaf, 0x14, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0xfc, 0x0, 0xfd, + 0x0, 0x0, 0x0, 0x5, 0xf7, 0x0, 0xaf, 0x30, + 0x0, 0x0, 0xb, 0xf2, 0x0, 0x5f, 0x90, 0x0, + 0x0, 0x1f, 0xd2, 0x22, 0x3f, 0xf0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0xcf, + 0x55, 0x55, 0x57, 0xfb, 0x0, 0x2, 0xfc, 0x0, + 0x0, 0x0, 0xef, 0x10, 0x7, 0xf5, 0x0, 0x0, + 0x0, 0x8f, 0x70, 0xd, 0xf0, 0x0, 0x0, 0x0, + 0x1f, 0xd0, + + /* U+0388 "Έ" */ + 0xd, 0xf2, 0x7f, 0xff, 0xff, 0xff, 0xfd, 0x4, + 0xf5, 0x7, 0xfb, 0x99, 0x99, 0x99, 0x80, 0x66, + 0x0, 0x7f, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xa9, 0x99, 0x99, 0x93, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x7f, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xb9, 0x99, 0x99, + 0x99, 0x10, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, + 0xf2, + + /* U+0389 "Ή" */ + 0xd, 0xf2, 0xde, 0x0, 0x0, 0x0, 0x7f, 0x44, + 0xf5, 0xd, 0xe0, 0x0, 0x0, 0x7, 0xf4, 0x66, + 0x0, 0xde, 0x0, 0x0, 0x0, 0x7f, 0x40, 0x0, + 0xd, 0xe0, 0x0, 0x0, 0x7, 0xf4, 0x0, 0x0, + 0xde, 0x0, 0x0, 0x0, 0x7f, 0x40, 0x0, 0xd, + 0xe0, 0x0, 0x0, 0x7, 0xf4, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, 0xd, 0xf9, + 0x99, 0x99, 0x9c, 0xf4, 0x0, 0x0, 0xde, 0x0, + 0x0, 0x0, 0x7f, 0x40, 0x0, 0xd, 0xe0, 0x0, + 0x0, 0x7, 0xf4, 0x0, 0x0, 0xde, 0x0, 0x0, + 0x0, 0x7f, 0x40, 0x0, 0xd, 0xe0, 0x0, 0x0, + 0x7, 0xf4, 0x0, 0x0, 0xde, 0x0, 0x0, 0x0, + 0x7f, 0x40, 0x0, 0xd, 0xe0, 0x0, 0x0, 0x7, + 0xf4, + + /* U+038A "Ί" */ + 0xd, 0xf2, 0xde, 0x4f, 0x50, 0xde, 0x66, 0x0, + 0xde, 0x0, 0x0, 0xde, 0x0, 0x0, 0xde, 0x0, + 0x0, 0xde, 0x0, 0x0, 0xde, 0x0, 0x0, 0xde, + 0x0, 0x0, 0xde, 0x0, 0x0, 0xde, 0x0, 0x0, + 0xde, 0x0, 0x0, 0xde, 0x0, 0x0, 0xde, 0x0, + 0x0, 0xde, + + /* U+038C "Ό" */ + 0xd, 0xf2, 0x7, 0xdf, 0xfc, 0x70, 0x0, 0x3, + 0xf6, 0x2e, 0xfc, 0x99, 0xdf, 0xc1, 0x0, 0x7a, + 0x1d, 0xf5, 0x0, 0x0, 0x6f, 0xc0, 0x0, 0x7, + 0xf6, 0x0, 0x0, 0x0, 0x8f, 0x50, 0x0, 0xde, + 0x0, 0x0, 0x0, 0x1, 0xfb, 0x0, 0x1f, 0xa0, + 0x0, 0x0, 0x0, 0xc, 0xf0, 0x2, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0x0, 0x2f, 0x80, 0x0, + 0x0, 0x0, 0xb, 0xf0, 0x1, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0x0, 0xd, 0xe0, 0x0, 0x0, + 0x0, 0x1f, 0xb0, 0x0, 0x7f, 0x60, 0x0, 0x0, + 0x8, 0xf5, 0x0, 0x0, 0xdf, 0x40, 0x0, 0x6, + 0xfc, 0x0, 0x0, 0x2, 0xdf, 0xc9, 0x9d, 0xfc, + 0x10, 0x0, 0x0, 0x0, 0x8d, 0xff, 0xc7, 0x0, + 0x0, + + /* U+038E "Ύ" */ + 0xd, 0xf2, 0x5f, 0xb0, 0x0, 0x0, 0x2, 0xfd, + 0x4, 0xf5, 0x0, 0xbf, 0x50, 0x0, 0x0, 0xbf, + 0x30, 0x66, 0x0, 0x2, 0xfe, 0x0, 0x0, 0x5f, + 0x80, 0x0, 0x0, 0x0, 0x7, 0xf8, 0x0, 0x1e, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xf2, 0x9, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xa2, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xde, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0x0, 0x0, 0x0, + + /* U+038F "Ώ" */ + 0xd, 0xf2, 0x7, 0xdf, 0xec, 0x50, 0x0, 0x3f, + 0x61, 0xdf, 0xc9, 0x9e, 0xf9, 0x0, 0x7a, 0xc, + 0xf7, 0x0, 0x1, 0xcf, 0x60, 0x0, 0x4f, 0xa0, + 0x0, 0x0, 0x1e, 0xe0, 0x0, 0xaf, 0x30, 0x0, + 0x0, 0x8, 0xf4, 0x0, 0xdf, 0x0, 0x0, 0x0, + 0x4, 0xf7, 0x0, 0xed, 0x0, 0x0, 0x0, 0x3, + 0xf8, 0x0, 0xde, 0x0, 0x0, 0x0, 0x4, 0xf7, + 0x0, 0xaf, 0x0, 0x0, 0x0, 0x5, 0xf4, 0x0, + 0x5f, 0x50, 0x0, 0x0, 0xa, 0xf0, 0x0, 0xc, + 0xc0, 0x0, 0x0, 0x2f, 0x70, 0x0, 0x2, 0xe9, + 0x0, 0x1, 0xdb, 0x0, 0x0, 0x99, 0xcf, 0xc0, + 0x3f, 0xfa, 0x96, 0x1, 0xff, 0xff, 0xf0, 0x5f, + 0xff, 0xfb, + + /* U+0390 "ΐ" */ + 0x3f, 0x54, 0xf9, 0xf3, 0x2c, 0x4a, 0x34, 0xc2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xc0, 0x0, 0x0, 0xc, 0xc0, 0x0, + 0x0, 0xc, 0xc0, 0x0, 0x0, 0xc, 0xc0, 0x0, + 0x0, 0xc, 0xc0, 0x0, 0x0, 0xc, 0xc0, 0x0, + 0x0, 0xc, 0xc0, 0x0, 0x0, 0xc, 0xc0, 0x0, + 0x0, 0xc, 0xc0, 0x0, 0x0, 0xc, 0xc0, 0x0, + + /* U+0391 "Α" */ + 0x0, 0x0, 0x3, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0xe, 0x9e, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0x5a, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xaf, 0x15, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0xfc, 0x0, 0xfd, + 0x0, 0x0, 0x0, 0x5, 0xf7, 0x0, 0xbf, 0x30, + 0x0, 0x0, 0xb, 0xf2, 0x0, 0x5f, 0x90, 0x0, + 0x0, 0x1f, 0xd2, 0x22, 0x3f, 0xf0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0xcf, + 0x55, 0x55, 0x57, 0xfb, 0x0, 0x2, 0xfc, 0x0, + 0x0, 0x0, 0xef, 0x10, 0x7, 0xf5, 0x0, 0x0, + 0x0, 0x8f, 0x70, 0xd, 0xf0, 0x0, 0x0, 0x0, + 0x1f, 0xd0, + + /* U+0392 "Β" */ + 0xaf, 0xff, 0xff, 0xd7, 0x0, 0xa, 0xf9, 0x99, + 0xad, 0xfb, 0x0, 0xaf, 0x0, 0x0, 0xa, 0xf4, + 0xa, 0xf0, 0x0, 0x0, 0x4f, 0x60, 0xaf, 0x0, + 0x0, 0x5, 0xf4, 0xa, 0xf0, 0x0, 0x4, 0xdd, + 0x0, 0xaf, 0xff, 0xff, 0xfe, 0x20, 0xa, 0xf9, + 0x99, 0xac, 0xfe, 0x20, 0xaf, 0x0, 0x0, 0x4, + 0xfb, 0xa, 0xf0, 0x0, 0x0, 0xc, 0xf0, 0xaf, + 0x0, 0x0, 0x0, 0xcf, 0xa, 0xf0, 0x0, 0x0, + 0x3f, 0xc0, 0xaf, 0x99, 0x99, 0xcf, 0xf4, 0xa, + 0xff, 0xff, 0xfe, 0xa3, 0x0, + + /* U+0393 "Γ" */ + 0x9f, 0xff, 0xff, 0xff, 0x89, 0xfa, 0x99, 0x99, + 0x94, 0x9f, 0x20, 0x0, 0x0, 0x9, 0xf2, 0x0, + 0x0, 0x0, 0x9f, 0x20, 0x0, 0x0, 0x9, 0xf2, + 0x0, 0x0, 0x0, 0x9f, 0x20, 0x0, 0x0, 0x9, + 0xf2, 0x0, 0x0, 0x0, 0x9f, 0x20, 0x0, 0x0, + 0x9, 0xf2, 0x0, 0x0, 0x0, 0x9f, 0x20, 0x0, + 0x0, 0x9, 0xf2, 0x0, 0x0, 0x0, 0x9f, 0x20, + 0x0, 0x0, 0x9, 0xf2, 0x0, 0x0, 0x0, + + /* U+0394 "Δ" */ + 0x0, 0x0, 0x3, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xef, 0x50, 0x0, 0x0, 0x0, 0x0, + 0xe, 0x8e, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0x49, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xaf, 0x3, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0xfa, 0x0, 0xed, + 0x0, 0x0, 0x0, 0x5, 0xf5, 0x0, 0x8f, 0x30, + 0x0, 0x0, 0xb, 0xf0, 0x0, 0x3f, 0x90, 0x0, + 0x0, 0x1f, 0xa0, 0x0, 0xd, 0xe0, 0x0, 0x0, + 0x6f, 0x50, 0x0, 0x8, 0xf5, 0x0, 0x0, 0xcf, + 0x0, 0x0, 0x2, 0xfb, 0x0, 0x2, 0xfa, 0x0, + 0x0, 0x0, 0xcf, 0x10, 0x7, 0xfc, 0x99, 0x99, + 0x99, 0xdf, 0x70, 0xd, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd0, + + /* U+0395 "Ε" */ + 0x9f, 0xff, 0xff, 0xff, 0xfb, 0x9, 0xfa, 0x99, + 0x99, 0x99, 0x60, 0x9f, 0x20, 0x0, 0x0, 0x0, + 0x9, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x9f, 0x20, + 0x0, 0x0, 0x0, 0x9, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xa9, 0x99, 0x99, 0x92, 0x9, 0xff, + 0xff, 0xff, 0xff, 0x40, 0x9f, 0x20, 0x0, 0x0, + 0x0, 0x9, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0x20, 0x0, 0x0, 0x0, 0x9, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xa9, 0x99, 0x99, 0x99, 0x9, + 0xff, 0xff, 0xff, 0xff, 0xf0, + + /* U+0396 "Ζ" */ + 0xe, 0xff, 0xff, 0xff, 0xff, 0x40, 0x89, 0x99, + 0x99, 0x9f, 0xf3, 0x0, 0x0, 0x0, 0x7, 0xfa, + 0x0, 0x0, 0x0, 0x3, 0xfd, 0x0, 0x0, 0x0, + 0x1, 0xef, 0x20, 0x0, 0x0, 0x0, 0xbf, 0x60, + 0x0, 0x0, 0x0, 0x6f, 0xa0, 0x0, 0x0, 0x0, + 0x2f, 0xe1, 0x0, 0x0, 0x0, 0xd, 0xf3, 0x0, + 0x0, 0x0, 0x9, 0xf7, 0x0, 0x0, 0x0, 0x5, + 0xfb, 0x0, 0x0, 0x0, 0x1, 0xee, 0x10, 0x0, + 0x0, 0x0, 0xaf, 0xc9, 0x99, 0x99, 0x99, 0x4a, + 0xff, 0xff, 0xff, 0xff, 0xf8, + + /* U+0397 "Η" */ + 0x9f, 0x20, 0x0, 0x0, 0x2f, 0x89, 0xf2, 0x0, + 0x0, 0x2, 0xf8, 0x9f, 0x20, 0x0, 0x0, 0x2f, + 0x89, 0xf2, 0x0, 0x0, 0x2, 0xf8, 0x9f, 0x20, + 0x0, 0x0, 0x2f, 0x89, 0xf2, 0x0, 0x0, 0x2, + 0xf8, 0x9f, 0xff, 0xff, 0xff, 0xff, 0x89, 0xfa, + 0x99, 0x99, 0x9a, 0xf8, 0x9f, 0x20, 0x0, 0x0, + 0x2f, 0x89, 0xf2, 0x0, 0x0, 0x2, 0xf8, 0x9f, + 0x20, 0x0, 0x0, 0x2f, 0x89, 0xf2, 0x0, 0x0, + 0x2, 0xf8, 0x9f, 0x20, 0x0, 0x0, 0x2f, 0x89, + 0xf2, 0x0, 0x0, 0x2, 0xf8, + + /* U+0398 "Θ" */ + 0x0, 0x0, 0x7c, 0xff, 0xc7, 0x0, 0x0, 0x0, + 0x1d, 0xfd, 0x99, 0xdf, 0xd1, 0x0, 0x0, 0xdf, + 0x50, 0x0, 0x6, 0xfd, 0x0, 0x6, 0xf7, 0x0, + 0x0, 0x0, 0x7f, 0x60, 0xc, 0xf0, 0x0, 0x0, + 0x0, 0xf, 0xd0, 0xf, 0xc0, 0x0, 0x0, 0x0, + 0xb, 0xf0, 0x1f, 0xa0, 0x59, 0x99, 0x95, 0xa, + 0xf2, 0x1f, 0xa0, 0x8f, 0xff, 0xf8, 0xa, 0xf2, + 0xf, 0xb0, 0x0, 0x0, 0x0, 0xb, 0xf0, 0xc, + 0xf0, 0x0, 0x0, 0x0, 0xf, 0xd0, 0x6, 0xf7, + 0x0, 0x0, 0x0, 0x7f, 0x70, 0x0, 0xdf, 0x50, + 0x0, 0x5, 0xfd, 0x0, 0x0, 0x1d, 0xfc, 0x99, + 0xcf, 0xd1, 0x0, 0x0, 0x0, 0x7d, 0xff, 0xc7, + 0x0, 0x0, + + /* U+0399 "Ι" */ + 0x5f, 0x55, 0xf5, 0x5f, 0x55, 0xf5, 0x5f, 0x55, + 0xf5, 0x5f, 0x55, 0xf5, 0x5f, 0x55, 0xf5, 0x5f, + 0x55, 0xf5, 0x5f, 0x55, 0xf5, + + /* U+039A "Κ" */ + 0xaf, 0x0, 0x0, 0x2, 0xef, 0x4a, 0xf0, 0x0, + 0x1, 0xdf, 0x50, 0xaf, 0x0, 0x0, 0xcf, 0x50, + 0xa, 0xf0, 0x0, 0xcf, 0x60, 0x0, 0xaf, 0x0, + 0xbf, 0x70, 0x0, 0xa, 0xf0, 0xaf, 0x90, 0x0, + 0x0, 0xaf, 0x9f, 0xfd, 0x0, 0x0, 0xa, 0xff, + 0x97, 0xf9, 0x0, 0x0, 0xaf, 0xa0, 0xc, 0xf4, + 0x0, 0xa, 0xf0, 0x0, 0x3f, 0xe0, 0x0, 0xaf, + 0x0, 0x0, 0x8f, 0x90, 0xa, 0xf0, 0x0, 0x0, + 0xdf, 0x40, 0xaf, 0x0, 0x0, 0x3, 0xfe, 0x1a, + 0xf0, 0x0, 0x0, 0x9, 0xfa, + + /* U+039B "Λ" */ + 0x0, 0x0, 0x1f, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0xcb, 0xbc, + 0x0, 0x0, 0x0, 0x2, 0xf6, 0x6f, 0x20, 0x0, + 0x0, 0x7, 0xf1, 0x1f, 0x70, 0x0, 0x0, 0xd, + 0xb0, 0xc, 0xd0, 0x0, 0x0, 0x3f, 0x60, 0x7, + 0xf3, 0x0, 0x0, 0x9f, 0x10, 0x1, 0xf9, 0x0, + 0x0, 0xeb, 0x0, 0x0, 0xce, 0x0, 0x4, 0xf6, + 0x0, 0x0, 0x7f, 0x40, 0xa, 0xf1, 0x0, 0x0, + 0x1f, 0xa0, 0xf, 0xb0, 0x0, 0x0, 0xc, 0xf0, + 0x5f, 0x50, 0x0, 0x0, 0x7, 0xf5, 0xbf, 0x0, + 0x0, 0x0, 0x2, 0xfb, + + /* U+039C "Μ" */ + 0xaf, 0xf1, 0x0, 0x0, 0x0, 0xcf, 0xaa, 0xff, + 0x60, 0x0, 0x0, 0x1f, 0xfa, 0xaf, 0xdb, 0x0, + 0x0, 0x7, 0xef, 0xaa, 0xf8, 0xf0, 0x0, 0x0, + 0xc9, 0xfa, 0xaf, 0x3f, 0x40, 0x0, 0x1f, 0x4f, + 0xaa, 0xf0, 0xe9, 0x0, 0x6, 0xf0, 0xfa, 0xaf, + 0x9, 0xe0, 0x0, 0xba, 0xf, 0xaa, 0xf0, 0x4f, + 0x30, 0xf, 0x50, 0xfa, 0xaf, 0x0, 0xf8, 0x5, + 0xf0, 0xf, 0xaa, 0xf0, 0xb, 0xd0, 0xab, 0x0, + 0xfa, 0xaf, 0x0, 0x6f, 0x2f, 0x60, 0xf, 0xaa, + 0xf0, 0x1, 0xfb, 0xf1, 0x0, 0xfa, 0xaf, 0x0, + 0xc, 0xfb, 0x0, 0xf, 0xaa, 0xf0, 0x0, 0x7f, + 0x60, 0x0, 0xfa, + + /* U+039D "Ν" */ + 0x9f, 0x70, 0x0, 0x0, 0x1f, 0x99, 0xff, 0x20, + 0x0, 0x1, 0xf9, 0x9f, 0xfb, 0x0, 0x0, 0x1f, + 0x99, 0xfb, 0xf5, 0x0, 0x1, 0xf9, 0x9f, 0x2e, + 0xe0, 0x0, 0x1f, 0x99, 0xf1, 0x6f, 0x80, 0x1, + 0xf9, 0x9f, 0x10, 0xcf, 0x30, 0x1f, 0x99, 0xf1, + 0x2, 0xfc, 0x1, 0xf9, 0x9f, 0x10, 0x8, 0xf6, + 0x1f, 0x99, 0xf1, 0x0, 0xe, 0xe2, 0xf9, 0x9f, + 0x10, 0x0, 0x5f, 0xbf, 0x99, 0xf1, 0x0, 0x0, + 0xbf, 0xf9, 0x9f, 0x10, 0x0, 0x2, 0xff, 0x99, + 0xf1, 0x0, 0x0, 0x7, 0xf9, + + /* U+039E "Ξ" */ + 0xc, 0xff, 0xff, 0xff, 0xff, 0x80, 0x79, 0x99, + 0x99, 0x99, 0x94, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x99, 0x99, 0x99, 0x96, 0x0, 0xf, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0x99, 0x99, 0x99, 0x99, 0x60, + 0xff, 0xff, 0xff, 0xff, 0xfb, + + /* U+039F "Ο" */ + 0x0, 0x0, 0x7c, 0xff, 0xc7, 0x0, 0x0, 0x0, + 0x1d, 0xfd, 0x99, 0xdf, 0xd1, 0x0, 0x0, 0xdf, + 0x50, 0x0, 0x6, 0xfd, 0x0, 0x6, 0xf7, 0x0, + 0x0, 0x0, 0x7f, 0x60, 0xc, 0xf0, 0x0, 0x0, + 0x0, 0xf, 0xd0, 0xf, 0xc0, 0x0, 0x0, 0x0, + 0xb, 0xf0, 0x1f, 0xa0, 0x0, 0x0, 0x0, 0xa, + 0xf2, 0x1f, 0xa0, 0x0, 0x0, 0x0, 0xa, 0xf2, + 0xf, 0xb0, 0x0, 0x0, 0x0, 0xb, 0xf0, 0xc, + 0xf0, 0x0, 0x0, 0x0, 0xf, 0xd0, 0x6, 0xf7, + 0x0, 0x0, 0x0, 0x7f, 0x70, 0x0, 0xdf, 0x50, + 0x0, 0x5, 0xfd, 0x0, 0x0, 0x1d, 0xfc, 0x99, + 0xcf, 0xd1, 0x0, 0x0, 0x0, 0x7d, 0xff, 0xc7, + 0x0, 0x0, + + /* U+03A0 "Π" */ + 0x9f, 0xff, 0xff, 0xff, 0xff, 0x89, 0xfa, 0x99, + 0x99, 0x9a, 0xf8, 0x9f, 0x20, 0x0, 0x0, 0x2f, + 0x89, 0xf2, 0x0, 0x0, 0x2, 0xf8, 0x9f, 0x20, + 0x0, 0x0, 0x2f, 0x89, 0xf2, 0x0, 0x0, 0x2, + 0xf8, 0x9f, 0x20, 0x0, 0x0, 0x2f, 0x89, 0xf2, + 0x0, 0x0, 0x2, 0xf8, 0x9f, 0x20, 0x0, 0x0, + 0x2f, 0x89, 0xf2, 0x0, 0x0, 0x2, 0xf8, 0x9f, + 0x20, 0x0, 0x0, 0x2f, 0x89, 0xf2, 0x0, 0x0, + 0x2, 0xf8, 0x9f, 0x20, 0x0, 0x0, 0x2f, 0x89, + 0xf2, 0x0, 0x0, 0x2, 0xf8, + + /* U+03A1 "Ρ" */ + 0x9f, 0xff, 0xff, 0xec, 0x50, 0x9, 0xfa, 0x99, + 0x9a, 0xef, 0x60, 0x9f, 0x10, 0x0, 0x2, 0xfe, + 0x9, 0xf1, 0x0, 0x0, 0xa, 0xf2, 0x9f, 0x10, + 0x0, 0x0, 0x9f, 0x39, 0xf1, 0x0, 0x0, 0xc, + 0xf0, 0x9f, 0x10, 0x0, 0x29, 0xfa, 0x9, 0xff, + 0xff, 0xff, 0xfd, 0x10, 0x9f, 0xa9, 0x99, 0x84, + 0x0, 0x9, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0x10, 0x0, 0x0, 0x0, 0x9, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0x10, 0x0, 0x0, 0x0, 0x9, + 0xf1, 0x0, 0x0, 0x0, 0x0, + + /* U+03A3 "Σ" */ + 0xbf, 0xff, 0xff, 0xff, 0xf1, 0xbf, 0xb9, 0x99, + 0x99, 0x90, 0x2f, 0xd1, 0x0, 0x0, 0x0, 0x4, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xa0, 0x0, + 0x0, 0x0, 0x8, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0x40, 0x0, 0x0, 0x2, 0xfe, 0x10, 0x0, + 0x0, 0xd, 0xf3, 0x0, 0x0, 0x0, 0xaf, 0x60, + 0x0, 0x0, 0x6, 0xf9, 0x0, 0x0, 0x0, 0x3f, + 0xc0, 0x0, 0x0, 0x0, 0xbf, 0xb9, 0x99, 0x99, + 0x94, 0xbf, 0xff, 0xff, 0xff, 0xf6, + + /* U+03A4 "Τ" */ + 0x9f, 0xff, 0xff, 0xff, 0xff, 0x95, 0x99, 0x9b, + 0xfb, 0x99, 0x95, 0x0, 0x0, 0x6f, 0x50, 0x0, + 0x0, 0x0, 0x6, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0x50, 0x0, 0x0, 0x0, 0x6, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0x50, 0x0, 0x0, 0x0, + 0x6, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x6f, 0x50, + 0x0, 0x0, 0x0, 0x6, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0x50, 0x0, 0x0, 0x0, 0x6, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0x50, 0x0, 0x0, + 0x0, 0x6, 0xf5, 0x0, 0x0, + + /* U+03A5 "Υ" */ + 0xaf, 0x60, 0x0, 0x0, 0x6, 0xf8, 0x1e, 0xe1, + 0x0, 0x0, 0x1f, 0xd0, 0x6, 0xfa, 0x0, 0x0, + 0xaf, 0x40, 0x0, 0xcf, 0x30, 0x3, 0xfa, 0x0, + 0x0, 0x3f, 0xc0, 0xd, 0xe1, 0x0, 0x0, 0x9, + 0xf6, 0x6f, 0x50, 0x0, 0x0, 0x0, 0xee, 0xeb, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xb0, 0x0, 0x0, + + /* U+03A6 "Φ" */ + 0x0, 0x0, 0x0, 0xaf, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0x20, 0x0, 0x0, 0x0, 0x8, + 0xef, 0xff, 0xff, 0xb3, 0x0, 0x0, 0xcf, 0xb7, + 0xcf, 0x68, 0xff, 0x40, 0x9, 0xf7, 0x0, 0xaf, + 0x0, 0x2f, 0xe0, 0xf, 0xd0, 0x0, 0xaf, 0x0, + 0x7, 0xf6, 0x2f, 0x90, 0x0, 0xaf, 0x0, 0x3, + 0xf9, 0x3f, 0x80, 0x0, 0xaf, 0x0, 0x2, 0xf9, + 0x1f, 0xb0, 0x0, 0xaf, 0x0, 0x5, 0xf6, 0xb, + 0xf4, 0x0, 0xaf, 0x0, 0xd, 0xf1, 0x2, 0xef, + 0x94, 0xbf, 0x36, 0xef, 0x60, 0x0, 0x2b, 0xff, + 0xff, 0xff, 0xd5, 0x0, 0x0, 0x0, 0x14, 0xcf, + 0x52, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x46, 0x0, 0x0, + 0x0, + + /* U+03A7 "Χ" */ + 0x1e, 0xe1, 0x0, 0x0, 0xa, 0xf3, 0x5, 0xfa, + 0x0, 0x0, 0x5f, 0x80, 0x0, 0xbf, 0x50, 0x1, + 0xfc, 0x0, 0x0, 0x1e, 0xe1, 0xc, 0xf2, 0x0, + 0x0, 0x6, 0xf9, 0x6f, 0x70, 0x0, 0x0, 0x0, + 0xbf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, + 0x0, 0x2, 0xfb, 0xcf, 0x40, 0x0, 0x0, 0xd, + 0xf2, 0x2f, 0xe0, 0x0, 0x0, 0x8f, 0x70, 0x7, + 0xf9, 0x0, 0x3, 0xfc, 0x0, 0x0, 0xdf, 0x30, + 0xd, 0xf2, 0x0, 0x0, 0x3f, 0xd0, 0x9f, 0x70, + 0x0, 0x0, 0x8, 0xf8, + + /* U+03A8 "Ψ" */ + 0xed, 0x0, 0x5, 0xf6, 0x0, 0xc, 0xee, 0xd0, + 0x0, 0x5f, 0x60, 0x0, 0xce, 0xed, 0x0, 0x5, + 0xf6, 0x0, 0xc, 0xee, 0xd0, 0x0, 0x5f, 0x60, + 0x0, 0xce, 0xdd, 0x0, 0x5, 0xf6, 0x0, 0xd, + 0xec, 0xf0, 0x0, 0x5f, 0x60, 0x0, 0xfd, 0x9f, + 0x30, 0x5, 0xf6, 0x0, 0x4f, 0x93, 0xfd, 0x10, + 0x5f, 0x60, 0x1d, 0xf3, 0x7, 0xff, 0xaa, 0xfb, + 0xaf, 0xf8, 0x0, 0x4, 0xbe, 0xff, 0xfe, 0xb4, + 0x0, 0x0, 0x0, 0x5, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0x60, 0x0, 0x0, + + /* U+03A9 "Ω" */ + 0x0, 0x1, 0x8d, 0xfe, 0xb4, 0x0, 0x0, 0x2, + 0xdf, 0xc9, 0xae, 0xf8, 0x0, 0x0, 0xdf, 0x50, + 0x0, 0x1c, 0xf5, 0x0, 0x6f, 0x90, 0x0, 0x0, + 0x2f, 0xd0, 0xb, 0xf1, 0x0, 0x0, 0x0, 0xaf, + 0x30, 0xee, 0x0, 0x0, 0x0, 0x6, 0xf5, 0xf, + 0xc0, 0x0, 0x0, 0x0, 0x4f, 0x70, 0xed, 0x0, + 0x0, 0x0, 0x5, 0xf6, 0xb, 0xf0, 0x0, 0x0, + 0x0, 0x7f, 0x30, 0x6f, 0x40, 0x0, 0x0, 0xc, + 0xd0, 0x0, 0xdb, 0x0, 0x0, 0x3, 0xf5, 0x0, + 0x3, 0xf8, 0x0, 0x2, 0xea, 0x0, 0x19, 0x9c, + 0xfb, 0x3, 0xff, 0x99, 0x52, 0xff, 0xff, 0xe0, + 0x6f, 0xff, 0xf9, + + /* U+03AA "Ϊ" */ + 0xf, 0xa0, 0xbe, 0xe, 0x90, 0xad, 0x0, 0x5f, + 0x50, 0x0, 0x5f, 0x50, 0x0, 0x5f, 0x50, 0x0, + 0x5f, 0x50, 0x0, 0x5f, 0x50, 0x0, 0x5f, 0x50, + 0x0, 0x5f, 0x50, 0x0, 0x5f, 0x50, 0x0, 0x5f, + 0x50, 0x0, 0x5f, 0x50, 0x0, 0x5f, 0x50, 0x0, + 0x5f, 0x50, 0x0, 0x5f, 0x50, 0x0, 0x5f, 0x50, + + /* U+03AB "Ϋ" */ + 0x0, 0x8, 0xf2, 0x3f, 0x60, 0x0, 0x0, 0x7, + 0xe2, 0x3e, 0x60, 0x0, 0xaf, 0x60, 0x0, 0x0, + 0x6, 0xf8, 0x1e, 0xe1, 0x0, 0x0, 0x1f, 0xd0, + 0x6, 0xfa, 0x0, 0x0, 0xaf, 0x40, 0x0, 0xcf, + 0x30, 0x3, 0xfa, 0x0, 0x0, 0x3f, 0xc0, 0xd, + 0xe1, 0x0, 0x0, 0x9, 0xf6, 0x6f, 0x50, 0x0, + 0x0, 0x0, 0xee, 0xeb, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xf, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xb0, 0x0, 0x0, + + /* U+03AC "ά" */ + 0x0, 0x0, 0xe, 0xe1, 0x0, 0x0, 0x0, 0x6f, + 0x30, 0x0, 0x0, 0x0, 0x75, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6d, 0xfd, 0x60, + 0xf9, 0x6, 0xfb, 0x35, 0xeb, 0xf5, 0xe, 0xd0, + 0x0, 0x3f, 0xf1, 0x3f, 0x80, 0x0, 0xe, 0xe0, + 0x5f, 0x60, 0x0, 0xc, 0xb0, 0x5f, 0x60, 0x0, + 0xc, 0xa0, 0x3f, 0x80, 0x0, 0xe, 0xd0, 0xe, + 0xd0, 0x0, 0x4f, 0xf1, 0x6, 0xf9, 0x25, 0xeb, + 0xf4, 0x0, 0x5d, 0xfe, 0x70, 0xf9, + + /* U+03AD "έ" */ + 0x0, 0x0, 0xee, 0x10, 0x0, 0x6, 0xf3, 0x0, + 0x0, 0x7, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9e, 0xfc, 0x50, 0x9, 0xf8, 0x7d, 0xd1, + 0xd, 0xb0, 0x0, 0x0, 0xa, 0xf5, 0x10, 0x0, + 0x1, 0xef, 0xf2, 0x0, 0xa, 0xf8, 0x50, 0x0, + 0x1f, 0xa0, 0x0, 0x0, 0xf, 0x90, 0x0, 0x60, + 0xb, 0xf8, 0x6c, 0xf5, 0x1, 0x9e, 0xfc, 0x50, + + /* U+03AE "ή" */ + 0x0, 0x1, 0xfc, 0x0, 0x0, 0x8, 0xf2, 0x0, + 0x0, 0x8, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xca, 0x6d, 0xfd, 0x60, 0xce, 0xe6, 0x4a, 0xf6, + 0xcf, 0x20, 0x0, 0xfb, 0xce, 0x0, 0x0, 0xdc, + 0xcc, 0x0, 0x0, 0xcc, 0xcc, 0x0, 0x0, 0xcd, + 0xcc, 0x0, 0x0, 0xcd, 0xcc, 0x0, 0x0, 0xcd, + 0xcc, 0x0, 0x0, 0xcd, 0xcc, 0x0, 0x0, 0xcd, + 0x0, 0x0, 0x0, 0xcd, 0x0, 0x0, 0x0, 0xcd, + 0x0, 0x0, 0x0, 0xcd, 0x0, 0x0, 0x0, 0xcd, + + /* U+03AF "ί" */ + 0x2, 0xfc, 0x0, 0x9e, 0x20, 0x8, 0x40, 0x0, + 0x0, 0x0, 0xc, 0xc0, 0x0, 0xcc, 0x0, 0xc, + 0xc0, 0x0, 0xcc, 0x0, 0xc, 0xc0, 0x0, 0xcc, + 0x0, 0xc, 0xc0, 0x0, 0xcc, 0x0, 0xc, 0xc0, + 0x0, 0xcc, 0x0, + + /* U+03B0 "ΰ" */ + 0x4f, 0x45, 0xe9, 0xf2, 0x3c, 0x3a, 0x34, 0xc1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcc, 0x0, 0x0, 0xea, 0xcc, 0x0, 0x0, 0xea, + 0xcc, 0x0, 0x0, 0xea, 0xcc, 0x0, 0x0, 0xea, + 0xcc, 0x0, 0x0, 0xea, 0xcc, 0x0, 0x0, 0xea, + 0xcd, 0x0, 0x0, 0xf9, 0x9f, 0x20, 0x4, 0xf6, + 0x2f, 0xe7, 0x7e, 0xe1, 0x3, 0xbf, 0xfa, 0x20, + + /* U+03B1 "α" */ + 0x0, 0x6d, 0xfd, 0x60, 0xf9, 0x6, 0xfb, 0x35, + 0xeb, 0xf5, 0xe, 0xd0, 0x0, 0x3f, 0xf1, 0x3f, + 0x80, 0x0, 0xe, 0xe0, 0x5f, 0x60, 0x0, 0xc, + 0xb0, 0x5f, 0x60, 0x0, 0xc, 0xa0, 0x3f, 0x80, + 0x0, 0xe, 0xd0, 0xe, 0xd0, 0x0, 0x4f, 0xf1, + 0x6, 0xf9, 0x25, 0xeb, 0xf4, 0x0, 0x5d, 0xfe, + 0x70, 0xf9, + + /* U+03B2 "β" */ + 0x1, 0x9e, 0xfc, 0x30, 0x1, 0xee, 0x77, 0xdf, + 0x10, 0x7f, 0x20, 0x1, 0xf9, 0xb, 0xd0, 0x0, + 0xc, 0xb0, 0xcc, 0x0, 0x0, 0xe9, 0xc, 0xc0, + 0x2, 0xae, 0x10, 0xcc, 0xc, 0xfd, 0x30, 0xc, + 0xc0, 0x24, 0x9f, 0x70, 0xcc, 0x0, 0x0, 0x9f, + 0x2c, 0xd0, 0x0, 0x3, 0xf7, 0xcf, 0x0, 0x0, + 0x2f, 0x7c, 0xf5, 0x0, 0x7, 0xf3, 0xce, 0xf7, + 0x47, 0xfb, 0xc, 0xc4, 0xcf, 0xe9, 0x0, 0xcc, + 0x0, 0x0, 0x0, 0xc, 0xc0, 0x0, 0x0, 0x0, + 0xcc, 0x0, 0x0, 0x0, 0xc, 0xc0, 0x0, 0x0, + 0x0, + + /* U+03B3 "γ" */ + 0x9f, 0x0, 0x0, 0xf, 0x94, 0xf5, 0x0, 0x5, + 0xf4, 0xe, 0xb0, 0x0, 0xae, 0x0, 0x9f, 0x0, + 0xf, 0x90, 0x3, 0xf5, 0x5, 0xf3, 0x0, 0xe, + 0xa0, 0xbe, 0x0, 0x0, 0x8f, 0x1f, 0x80, 0x0, + 0x3, 0xfa, 0xf3, 0x0, 0x0, 0xd, 0xfd, 0x0, + 0x0, 0x0, 0x8f, 0x80, 0x0, 0x0, 0x5, 0xf4, + 0x0, 0x0, 0x0, 0x5f, 0x40, 0x0, 0x0, 0x5, + 0xf4, 0x0, 0x0, 0x0, 0x5f, 0x40, 0x0, + + /* U+03B4 "δ" */ + 0x7, 0xff, 0xff, 0xff, 0x90, 0x3, 0xff, 0x65, + 0x55, 0x30, 0x0, 0x3e, 0xc1, 0x0, 0x0, 0x0, + 0x2, 0xee, 0x30, 0x0, 0x0, 0x5d, 0xff, 0xf5, + 0x0, 0x5, 0xfc, 0x55, 0xcf, 0x50, 0xe, 0xe0, + 0x0, 0xd, 0xe0, 0x3f, 0x70, 0x0, 0x7, 0xf3, + 0x5f, 0x40, 0x0, 0x4, 0xf5, 0x5f, 0x50, 0x0, + 0x4, 0xf5, 0x2f, 0x80, 0x0, 0x7, 0xf3, 0xd, + 0xe1, 0x0, 0xe, 0xd0, 0x4, 0xfd, 0x77, 0xdf, + 0x40, 0x0, 0x4c, 0xff, 0xb3, 0x0, + + /* U+03B5 "ε" */ + 0x0, 0x9e, 0xfc, 0x50, 0x9, 0xf8, 0x7d, 0xd1, + 0xd, 0xb0, 0x0, 0x0, 0xa, 0xf5, 0x10, 0x0, + 0x1, 0xef, 0xf2, 0x0, 0xa, 0xf8, 0x50, 0x0, + 0x1f, 0xa0, 0x0, 0x0, 0xf, 0x90, 0x0, 0x60, + 0xb, 0xf8, 0x6c, 0xf5, 0x1, 0x9e, 0xfc, 0x50, + + /* U+03B6 "ζ" */ + 0x0, 0xff, 0xff, 0xfc, 0x0, 0x55, 0x5c, 0xf5, + 0x0, 0x0, 0x8e, 0x30, 0x0, 0x8, 0xf3, 0x0, + 0x0, 0x4f, 0x60, 0x0, 0x0, 0xea, 0x0, 0x0, + 0x7, 0xf2, 0x0, 0x0, 0xe, 0xb0, 0x0, 0x0, + 0x2f, 0x60, 0x0, 0x0, 0x5f, 0x40, 0x0, 0x0, + 0x5f, 0x40, 0x0, 0x0, 0x2f, 0xa0, 0x0, 0x0, + 0xc, 0xfd, 0xa7, 0x20, 0x1, 0xbf, 0xff, 0xf2, + 0x0, 0x0, 0x4, 0xf8, 0x0, 0x0, 0x0, 0xf8, + 0x0, 0x0, 0x4d, 0xf2, 0x0, 0x0, 0xac, 0x30, + + /* U+03B7 "η" */ + 0xca, 0x6d, 0xfd, 0x60, 0xce, 0xe6, 0x4a, 0xf6, + 0xcf, 0x20, 0x0, 0xfb, 0xce, 0x0, 0x0, 0xdc, + 0xcc, 0x0, 0x0, 0xcc, 0xcc, 0x0, 0x0, 0xcd, + 0xcc, 0x0, 0x0, 0xcd, 0xcc, 0x0, 0x0, 0xcd, + 0xcc, 0x0, 0x0, 0xcd, 0xcc, 0x0, 0x0, 0xcd, + 0x0, 0x0, 0x0, 0xcd, 0x0, 0x0, 0x0, 0xcd, + 0x0, 0x0, 0x0, 0xcd, 0x0, 0x0, 0x0, 0xcd, + + /* U+03B8 "θ" */ + 0x0, 0x1a, 0xff, 0xb2, 0x0, 0x0, 0xde, 0x77, + 0xee, 0x10, 0x7, 0xf2, 0x0, 0x2f, 0x80, 0xc, + 0xc0, 0x0, 0xb, 0xd0, 0xf, 0x80, 0x0, 0x8, + 0xf0, 0x1f, 0x81, 0x11, 0x17, 0xf2, 0x2f, 0xff, + 0xff, 0xff, 0xf3, 0x2f, 0x94, 0x44, 0x49, 0xf3, + 0x2f, 0x80, 0x0, 0x7, 0xf2, 0xf, 0xa0, 0x0, + 0x9, 0xf0, 0xc, 0xd0, 0x0, 0xd, 0xd0, 0x7, + 0xf4, 0x0, 0x3f, 0x80, 0x0, 0xee, 0x77, 0xee, + 0x10, 0x0, 0x1a, 0xff, 0xb2, 0x0, + + /* U+03B9 "ι" */ + 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, + 0xcc, 0xcc, + + /* U+03BA "κ" */ + 0xdc, 0x0, 0x1d, 0xe3, 0xdc, 0x1, 0xde, 0x30, + 0xdc, 0x1c, 0xe3, 0x0, 0xdc, 0xce, 0x30, 0x0, + 0xdf, 0xfb, 0x0, 0x0, 0xde, 0xaf, 0x70, 0x0, + 0xdc, 0xb, 0xf4, 0x0, 0xdc, 0x1, 0xee, 0x10, + 0xdc, 0x0, 0x3f, 0xc0, 0xdc, 0x0, 0x6, 0xf9, + + /* U+03BB "λ" */ + 0x0, 0x8f, 0x20, 0x0, 0x0, 0x3, 0xf7, 0x0, + 0x0, 0x0, 0xd, 0xc0, 0x0, 0x0, 0x0, 0x8f, + 0x20, 0x0, 0x0, 0x7, 0xf7, 0x0, 0x0, 0x0, + 0xdf, 0xd0, 0x0, 0x0, 0x2f, 0xff, 0x20, 0x0, + 0x8, 0xf6, 0xf8, 0x0, 0x0, 0xdd, 0xd, 0xd0, + 0x0, 0x3f, 0x70, 0x8f, 0x30, 0x9, 0xf2, 0x2, + 0xf8, 0x0, 0xec, 0x0, 0xc, 0xe0, 0x4f, 0x60, + 0x0, 0x6f, 0x39, 0xf1, 0x0, 0x1, 0xf9, + + /* U+03BC "μ" */ + 0xcc, 0x0, 0x0, 0xcc, 0xcc, 0x0, 0x0, 0xcc, + 0xcc, 0x0, 0x0, 0xcc, 0xcc, 0x0, 0x0, 0xcc, + 0xcc, 0x0, 0x0, 0xcc, 0xcd, 0x0, 0x0, 0xcc, + 0xce, 0x0, 0x0, 0xec, 0xcf, 0x20, 0x2, 0xfc, + 0xcf, 0xd5, 0x6e, 0xfc, 0xcd, 0x8e, 0xf9, 0xac, + 0xcc, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x0, 0x0, + 0xcc, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x0, 0x0, + + /* U+03BD "ν" */ + 0x9f, 0x10, 0x0, 0xf, 0x93, 0xf6, 0x0, 0x5, + 0xf4, 0xe, 0xb0, 0x0, 0xbe, 0x0, 0x8f, 0x10, + 0xf, 0x80, 0x2, 0xf6, 0x5, 0xf3, 0x0, 0xd, + 0xb0, 0xbd, 0x0, 0x0, 0x7f, 0x2f, 0x70, 0x0, + 0x1, 0xfb, 0xf2, 0x0, 0x0, 0xc, 0xfc, 0x0, + 0x0, 0x0, 0x6f, 0x60, 0x0, + + /* U+03BE "ξ" */ + 0x0, 0x3b, 0xef, 0xc0, 0x2, 0xfd, 0x76, 0x40, + 0x9, 0xe0, 0x0, 0x0, 0xa, 0xd0, 0x0, 0x0, + 0x5, 0xf8, 0x21, 0x10, 0x0, 0x6d, 0xff, 0xb0, + 0x0, 0x5e, 0xc6, 0x30, 0x4, 0xf8, 0x0, 0x0, + 0xd, 0xd0, 0x0, 0x0, 0x1f, 0x80, 0x0, 0x0, + 0x2f, 0x70, 0x0, 0x0, 0xf, 0xd0, 0x0, 0x0, + 0x7, 0xfd, 0x96, 0x10, 0x0, 0x5c, 0xff, 0xf2, + 0x0, 0x0, 0x5, 0xfa, 0x0, 0x0, 0x0, 0xea, + 0x0, 0x0, 0x4c, 0xf4, 0x0, 0x0, 0xac, 0x40, + + /* U+03BF "ο" */ + 0x0, 0x3b, 0xff, 0xb3, 0x0, 0x4, 0xfd, 0x77, + 0xdf, 0x40, 0xe, 0xe1, 0x0, 0x1e, 0xe0, 0x3f, + 0x70, 0x0, 0x7, 0xf3, 0x5f, 0x50, 0x0, 0x4, + 0xf5, 0x5f, 0x50, 0x0, 0x5, 0xf5, 0x3f, 0x70, + 0x0, 0x7, 0xf3, 0xe, 0xe0, 0x0, 0xe, 0xe0, + 0x5, 0xfd, 0x77, 0xdf, 0x50, 0x0, 0x3b, 0xff, + 0xc4, 0x0, + + /* U+03C0 "π" */ + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3, 0x56, + 0xfa, 0x55, 0x5c, 0xf5, 0x50, 0x0, 0x2f, 0x70, + 0x0, 0xae, 0x0, 0x0, 0x2, 0xf7, 0x0, 0xa, + 0xe0, 0x0, 0x0, 0x2f, 0x70, 0x0, 0xae, 0x0, + 0x0, 0x2, 0xf7, 0x0, 0xa, 0xe0, 0x0, 0x0, + 0x2f, 0x70, 0x0, 0xae, 0x0, 0x0, 0x2, 0xf7, + 0x0, 0xa, 0xe0, 0x0, 0x0, 0x2f, 0x70, 0x0, + 0xae, 0x0, 0x0, 0x2, 0xf7, 0x0, 0xa, 0xe0, + 0x0, + + /* U+03C1 "ρ" */ + 0x1, 0xae, 0xfc, 0x50, 0x0, 0xdf, 0x97, 0xcf, + 0x70, 0x6f, 0x50, 0x0, 0xaf, 0x1a, 0xe0, 0x0, + 0x3, 0xf6, 0xcc, 0x0, 0x0, 0xf, 0x9d, 0xc0, + 0x0, 0x1, 0xf9, 0xde, 0x0, 0x0, 0x3f, 0x6d, + 0xf5, 0x0, 0xa, 0xf2, 0xdf, 0xf8, 0x6b, 0xf8, + 0xd, 0xb7, 0xdf, 0xd6, 0x0, 0xdb, 0x0, 0x0, + 0x0, 0xd, 0xb0, 0x0, 0x0, 0x0, 0xdb, 0x0, + 0x0, 0x0, 0xd, 0xb0, 0x0, 0x0, 0x0, + + /* U+03C2 "ς" */ + 0x0, 0x4, 0xbe, 0xfe, 0x40, 0x8, 0xfb, 0x76, + 0x82, 0x5, 0xf6, 0x0, 0x0, 0x0, 0xdb, 0x0, + 0x0, 0x0, 0x2f, 0x60, 0x0, 0x0, 0x3, 0xf5, + 0x0, 0x0, 0x0, 0x1f, 0x90, 0x0, 0x0, 0x0, + 0xbf, 0x50, 0x0, 0x0, 0x2, 0xdf, 0xd7, 0x20, + 0x0, 0x1, 0x7d, 0xff, 0x50, 0x0, 0x0, 0x2, + 0xdf, 0x0, 0x0, 0x0, 0xb, 0xf0, 0x0, 0x3, + 0x9b, 0xf9, 0x0, 0x0, 0x8f, 0xe8, 0x0, + + /* U+03C3 "σ" */ + 0x0, 0x3b, 0xff, 0xff, 0xff, 0xb0, 0x5f, 0xfa, + 0xaf, 0xfb, 0x96, 0xe, 0xe2, 0x0, 0x2e, 0xd0, + 0x4, 0xf7, 0x0, 0x0, 0x8f, 0x20, 0x6f, 0x40, + 0x0, 0x5, 0xf4, 0x6, 0xf4, 0x0, 0x0, 0x5f, + 0x40, 0x4f, 0x60, 0x0, 0x7, 0xf3, 0x0, 0xed, + 0x0, 0x0, 0xee, 0x0, 0x5, 0xfd, 0x77, 0xdf, + 0x40, 0x0, 0x4, 0xcf, 0xfb, 0x30, 0x0, + + /* U+03C4 "τ" */ + 0x9f, 0xff, 0xff, 0xb3, 0x56, 0xfa, 0x53, 0x0, + 0x2f, 0x70, 0x0, 0x2, 0xf7, 0x0, 0x0, 0x2f, + 0x70, 0x0, 0x2, 0xf7, 0x0, 0x0, 0x2f, 0x70, + 0x0, 0x2, 0xf7, 0x0, 0x0, 0x2f, 0x70, 0x0, + 0x2, 0xf7, 0x0, + + /* U+03C5 "υ" */ + 0xcc, 0x0, 0x0, 0xea, 0xcc, 0x0, 0x0, 0xea, + 0xcc, 0x0, 0x0, 0xea, 0xcc, 0x0, 0x0, 0xea, + 0xcc, 0x0, 0x0, 0xea, 0xcc, 0x0, 0x0, 0xea, + 0xcd, 0x0, 0x0, 0xf9, 0x9f, 0x20, 0x4, 0xf6, + 0x2f, 0xe7, 0x7e, 0xe1, 0x3, 0xbf, 0xfa, 0x20, + + /* U+03C6 "φ" */ + 0x0, 0x5d, 0x45, 0xef, 0xc3, 0x0, 0x5, 0xfb, + 0xc, 0xf7, 0xcf, 0x20, 0xe, 0xc0, 0xe, 0xb0, + 0x1f, 0x90, 0x3f, 0x60, 0xe, 0xb0, 0xb, 0xe0, + 0x5f, 0x40, 0xe, 0xb0, 0xa, 0xf0, 0x4f, 0x50, + 0xe, 0xb0, 0xb, 0xf0, 0x1f, 0xa0, 0xe, 0xb0, + 0x1f, 0xa0, 0xa, 0xf4, 0xe, 0xb0, 0xaf, 0x30, + 0x1, 0xdf, 0xae, 0xdd, 0xf6, 0x0, 0x0, 0x19, + 0xef, 0xfb, 0x30, 0x0, 0x0, 0x0, 0xe, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xb0, 0x0, 0x0, + + /* U+03C7 "χ" */ + 0x5f, 0x50, 0x0, 0xd, 0xd0, 0xd, 0xd0, 0x0, + 0x5f, 0x50, 0x6, 0xf4, 0x0, 0xdd, 0x0, 0x0, + 0xeb, 0x4, 0xf5, 0x0, 0x0, 0x6f, 0x3c, 0xd0, + 0x0, 0x0, 0xe, 0xdf, 0x50, 0x0, 0x0, 0x7, + 0xfd, 0x0, 0x0, 0x0, 0x8, 0xfe, 0x0, 0x0, + 0x0, 0x1f, 0xaf, 0x70, 0x0, 0x0, 0x8f, 0x1a, + 0xe0, 0x0, 0x1, 0xf9, 0x2, 0xf7, 0x0, 0x9, + 0xf2, 0x0, 0xbf, 0x10, 0x1f, 0xa0, 0x0, 0x3f, + 0x80, 0x9f, 0x20, 0x0, 0xc, 0xf1, + + /* U+03C8 "ψ" */ + 0xea, 0x0, 0x6f, 0x30, 0xd, 0xce, 0xa0, 0x6, + 0xf3, 0x0, 0xdc, 0xea, 0x0, 0x6f, 0x30, 0xd, + 0xce, 0xa0, 0x6, 0xf3, 0x0, 0xdc, 0xea, 0x0, + 0x6f, 0x30, 0xd, 0xbe, 0xa0, 0x6, 0xf3, 0x0, + 0xdb, 0xdc, 0x0, 0x6f, 0x30, 0xf, 0xa9, 0xf2, + 0x6, 0xf3, 0x5, 0xf6, 0x1e, 0xf9, 0xaf, 0x89, + 0xfd, 0x0, 0x1a, 0xef, 0xff, 0xd8, 0x10, 0x0, + 0x0, 0x6f, 0x30, 0x0, 0x0, 0x0, 0x6, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0x30, 0x0, 0x0, + 0x0, 0x6, 0xf3, 0x0, 0x0, + + /* U+03C9 "ω" */ + 0x1, 0xf7, 0x0, 0x0, 0x0, 0x6f, 0x20, 0x8, + 0xf1, 0x0, 0x0, 0x0, 0x1f, 0x90, 0xd, 0xc0, + 0x0, 0x66, 0x0, 0xb, 0xe0, 0x1f, 0x80, 0x0, + 0xcd, 0x0, 0x8, 0xf2, 0x3f, 0x60, 0x0, 0xcd, + 0x0, 0x5, 0xf4, 0x2f, 0x60, 0x0, 0xcd, 0x0, + 0x5, 0xf4, 0x1f, 0x80, 0x0, 0xde, 0x0, 0x7, + 0xf2, 0xd, 0xd0, 0x1, 0xff, 0x20, 0xc, 0xe0, + 0x5, 0xfb, 0x5c, 0xa9, 0xd5, 0xaf, 0x70, 0x0, + 0x7e, 0xfa, 0x0, 0x9f, 0xe7, 0x0, + + /* U+03CA "ϊ" */ + 0x7f, 0x23, 0xf7, 0x6e, 0x22, 0xe6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x0, + 0xcc, 0x0, 0x0, 0xcc, 0x0, 0x0, 0xcc, 0x0, + 0x0, 0xcc, 0x0, 0x0, 0xcc, 0x0, 0x0, 0xcc, + 0x0, 0x0, 0xcc, 0x0, 0x0, 0xcc, 0x0, 0x0, + 0xcc, 0x0, + + /* U+03CB "ϋ" */ + 0x8, 0xf1, 0x4f, 0x60, 0x7, 0xe1, 0x3e, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcc, 0x0, 0x0, 0xea, 0xcc, 0x0, 0x0, 0xea, + 0xcc, 0x0, 0x0, 0xea, 0xcc, 0x0, 0x0, 0xea, + 0xcc, 0x0, 0x0, 0xea, 0xcc, 0x0, 0x0, 0xea, + 0xcd, 0x0, 0x0, 0xf9, 0x9f, 0x20, 0x4, 0xf6, + 0x2f, 0xe7, 0x7e, 0xe1, 0x3, 0xbf, 0xfa, 0x20, + + /* U+03CC "ό" */ + 0x0, 0x0, 0x1f, 0xc0, 0x0, 0x0, 0x0, 0x8f, + 0x20, 0x0, 0x0, 0x0, 0x84, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3b, 0xff, 0xb3, + 0x0, 0x4, 0xfd, 0x77, 0xdf, 0x40, 0xe, 0xe1, + 0x0, 0x1e, 0xe0, 0x3f, 0x70, 0x0, 0x7, 0xf3, + 0x5f, 0x50, 0x0, 0x4, 0xf5, 0x5f, 0x50, 0x0, + 0x5, 0xf5, 0x3f, 0x70, 0x0, 0x7, 0xf3, 0xe, + 0xe0, 0x0, 0xe, 0xe0, 0x5, 0xfd, 0x77, 0xdf, + 0x50, 0x0, 0x3b, 0xff, 0xc4, 0x0, + + /* U+03CD "ύ" */ + 0x0, 0x2, 0xfb, 0x0, 0x0, 0xa, 0xe1, 0x0, + 0x0, 0x8, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcc, 0x0, 0x0, 0xea, 0xcc, 0x0, 0x0, 0xea, + 0xcc, 0x0, 0x0, 0xea, 0xcc, 0x0, 0x0, 0xea, + 0xcc, 0x0, 0x0, 0xea, 0xcc, 0x0, 0x0, 0xea, + 0xcd, 0x0, 0x0, 0xf9, 0x9f, 0x20, 0x4, 0xf6, + 0x2f, 0xe7, 0x7e, 0xe1, 0x3, 0xbf, 0xfa, 0x20, + + /* U+03CE "ώ" */ + 0x0, 0x0, 0x0, 0x1f, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x84, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xf7, 0x0, 0x0, + 0x0, 0x6f, 0x20, 0x8, 0xf1, 0x0, 0x0, 0x0, + 0x1f, 0x90, 0xd, 0xc0, 0x0, 0x66, 0x0, 0xb, + 0xe0, 0x1f, 0x80, 0x0, 0xcd, 0x0, 0x8, 0xf2, + 0x3f, 0x60, 0x0, 0xcd, 0x0, 0x5, 0xf4, 0x2f, + 0x60, 0x0, 0xcd, 0x0, 0x5, 0xf4, 0x1f, 0x80, + 0x0, 0xde, 0x0, 0x7, 0xf2, 0xd, 0xd0, 0x1, + 0xff, 0x20, 0xc, 0xe0, 0x5, 0xfb, 0x5c, 0xa9, + 0xd5, 0xaf, 0x70, 0x0, 0x7e, 0xfa, 0x0, 0x9f, + 0xe7, 0x0, + + /* U+03F4 "ϴ" */ + 0x3f, 0x54, 0xf9, 0xf3, 0x2c, 0x4a, 0x34, 0xc2 +}; + + +/*--------------------- + * GLYPH DESCRIPTION + *--------------------*/ + +static const lv_font_fmt_txt_glyph_dsc_t glyph_dsc[] = { + {.bitmap_index = 0, .adv_w = 0, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0} /* id = 0 reserved */, + {.bitmap_index = 0, .adv_w = 80, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 0, .adv_w = 80, .box_w = 3, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 21, .adv_w = 102, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 9}, + {.bitmap_index = 36, .adv_w = 160, .box_w = 10, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 106, .adv_w = 160, .box_w = 10, .box_h = 17, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 191, .adv_w = 256, .box_w = 14, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 289, .adv_w = 192, .box_w = 12, .box_h = 15, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 379, .adv_w = 55, .box_w = 3, .box_h = 5, .ofs_x = 0, .ofs_y = 9}, + {.bitmap_index = 387, .adv_w = 96, .box_w = 5, .box_h = 18, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 432, .adv_w = 96, .box_w = 5, .box_h = 18, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 477, .adv_w = 112, .box_w = 7, .box_h = 6, .ofs_x = 0, .ofs_y = 8}, + {.bitmap_index = 498, .adv_w = 168, .box_w = 9, .box_h = 9, .ofs_x = 1, .ofs_y = 2}, + {.bitmap_index = 539, .adv_w = 80, .box_w = 3, .box_h = 5, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 547, .adv_w = 96, .box_w = 6, .box_h = 2, .ofs_x = 0, .ofs_y = 4}, + {.bitmap_index = 553, .adv_w = 80, .box_w = 3, .box_h = 2, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 556, .adv_w = 80, .box_w = 5, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 591, .adv_w = 160, .box_w = 10, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 661, .adv_w = 160, .box_w = 5, .box_h = 14, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 696, .adv_w = 160, .box_w = 10, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 766, .adv_w = 160, .box_w = 10, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 836, .adv_w = 160, .box_w = 10, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 906, .adv_w = 160, .box_w = 10, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 976, .adv_w = 160, .box_w = 10, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1046, .adv_w = 160, .box_w = 10, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1116, .adv_w = 160, .box_w = 10, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1186, .adv_w = 160, .box_w = 10, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1256, .adv_w = 80, .box_w = 3, .box_h = 10, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1271, .adv_w = 80, .box_w = 3, .box_h = 13, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 1291, .adv_w = 168, .box_w = 9, .box_h = 10, .ofs_x = 1, .ofs_y = 2}, + {.bitmap_index = 1336, .adv_w = 168, .box_w = 9, .box_h = 6, .ofs_x = 1, .ofs_y = 4}, + {.bitmap_index = 1363, .adv_w = 168, .box_w = 9, .box_h = 10, .ofs_x = 1, .ofs_y = 2}, + {.bitmap_index = 1408, .adv_w = 160, .box_w = 10, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1478, .adv_w = 292, .box_w = 17, .box_h = 18, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 1631, .adv_w = 192, .box_w = 14, .box_h = 14, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 1729, .adv_w = 192, .box_w = 11, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1806, .adv_w = 208, .box_w = 13, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1897, .adv_w = 208, .box_w = 12, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1981, .adv_w = 192, .box_w = 11, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2058, .adv_w = 176, .box_w = 10, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2128, .adv_w = 224, .box_w = 13, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2219, .adv_w = 208, .box_w = 11, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2296, .adv_w = 80, .box_w = 3, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2317, .adv_w = 144, .box_w = 8, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2373, .adv_w = 192, .box_w = 11, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2450, .adv_w = 160, .box_w = 9, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2513, .adv_w = 240, .box_w = 13, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2604, .adv_w = 208, .box_w = 11, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2681, .adv_w = 224, .box_w = 14, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2779, .adv_w = 192, .box_w = 11, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2856, .adv_w = 224, .box_w = 14, .box_h = 15, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 2961, .adv_w = 208, .box_w = 12, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3045, .adv_w = 192, .box_w = 12, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3129, .adv_w = 176, .box_w = 11, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3206, .adv_w = 208, .box_w = 11, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3283, .adv_w = 192, .box_w = 12, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3367, .adv_w = 272, .box_w = 17, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3486, .adv_w = 192, .box_w = 12, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3570, .adv_w = 192, .box_w = 12, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3654, .adv_w = 176, .box_w = 11, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3731, .adv_w = 80, .box_w = 4, .box_h = 18, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 3767, .adv_w = 80, .box_w = 5, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3802, .adv_w = 80, .box_w = 4, .box_h = 18, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 3838, .adv_w = 135, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 6}, + {.bitmap_index = 3870, .adv_w = 160, .box_w = 12, .box_h = 3, .ofs_x = -1, .ofs_y = -5}, + {.bitmap_index = 3888, .adv_w = 96, .box_w = 5, .box_h = 3, .ofs_x = 0, .ofs_y = 11}, + {.bitmap_index = 3896, .adv_w = 160, .box_w = 10, .box_h = 10, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3946, .adv_w = 160, .box_w = 9, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4009, .adv_w = 144, .box_w = 9, .box_h = 10, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4054, .adv_w = 160, .box_w = 9, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4117, .adv_w = 160, .box_w = 10, .box_h = 10, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4167, .adv_w = 80, .box_w = 6, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4209, .adv_w = 160, .box_w = 9, .box_h = 14, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 4272, .adv_w = 160, .box_w = 8, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4328, .adv_w = 64, .box_w = 2, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4342, .adv_w = 64, .box_w = 4, .box_h = 18, .ofs_x = -1, .ofs_y = -4}, + {.bitmap_index = 4378, .adv_w = 144, .box_w = 8, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4434, .adv_w = 64, .box_w = 2, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4448, .adv_w = 240, .box_w = 13, .box_h = 10, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4513, .adv_w = 160, .box_w = 8, .box_h = 10, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4553, .adv_w = 160, .box_w = 10, .box_h = 10, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4603, .adv_w = 160, .box_w = 9, .box_h = 14, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 4666, .adv_w = 160, .box_w = 9, .box_h = 14, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 4729, .adv_w = 96, .box_w = 6, .box_h = 10, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4759, .adv_w = 144, .box_w = 9, .box_h = 10, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4804, .adv_w = 80, .box_w = 5, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4839, .adv_w = 160, .box_w = 8, .box_h = 10, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4879, .adv_w = 144, .box_w = 9, .box_h = 10, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4924, .adv_w = 208, .box_w = 13, .box_h = 10, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4989, .adv_w = 144, .box_w = 9, .box_h = 10, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5034, .adv_w = 144, .box_w = 9, .box_h = 14, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 5097, .adv_w = 144, .box_w = 9, .box_h = 10, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5142, .adv_w = 96, .box_w = 6, .box_h = 18, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 5196, .adv_w = 75, .box_w = 3, .box_h = 18, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 5223, .adv_w = 96, .box_w = 6, .box_h = 18, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 5277, .adv_w = 168, .box_w = 10, .box_h = 5, .ofs_x = 0, .ofs_y = 4}, + {.bitmap_index = 5302, .adv_w = 80, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5302, .adv_w = 160, .box_w = 10, .box_h = 15, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 5377, .adv_w = 160, .box_w = 10, .box_h = 10, .ofs_x = 0, .ofs_y = 2}, + {.bitmap_index = 5427, .adv_w = 160, .box_w = 10, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5497, .adv_w = 75, .box_w = 3, .box_h = 18, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 5524, .adv_w = 160, .box_w = 10, .box_h = 18, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 5614, .adv_w = 96, .box_w = 6, .box_h = 2, .ofs_x = 0, .ofs_y = 12}, + {.bitmap_index = 5620, .adv_w = 212, .box_w = 14, .box_h = 15, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 5725, .adv_w = 108, .box_w = 7, .box_h = 7, .ofs_x = 0, .ofs_y = 6}, + {.bitmap_index = 5750, .adv_w = 160, .box_w = 8, .box_h = 9, .ofs_x = 1, .ofs_y = 1}, + {.bitmap_index = 5786, .adv_w = 168, .box_w = 9, .box_h = 6, .ofs_x = 1, .ofs_y = 4}, + {.bitmap_index = 5813, .adv_w = 96, .box_w = 6, .box_h = 2, .ofs_x = 0, .ofs_y = 4}, + {.bitmap_index = 5819, .adv_w = 212, .box_w = 14, .box_h = 15, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 5924, .adv_w = 115, .box_w = 6, .box_h = 6, .ofs_x = 1, .ofs_y = 8}, + {.bitmap_index = 5942, .adv_w = 168, .box_w = 9, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 5992, .adv_w = 96, .box_w = 6, .box_h = 7, .ofs_x = 0, .ofs_y = 6}, + {.bitmap_index = 6013, .adv_w = 96, .box_w = 6, .box_h = 7, .ofs_x = 0, .ofs_y = 6}, + {.bitmap_index = 6034, .adv_w = 160, .box_w = 8, .box_h = 14, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 6090, .adv_w = 155, .box_w = 11, .box_h = 18, .ofs_x = -1, .ofs_y = -4}, + {.bitmap_index = 6189, .adv_w = 81, .box_w = 3, .box_h = 2, .ofs_x = 1, .ofs_y = 6}, + {.bitmap_index = 6192, .adv_w = 160, .box_w = 8, .box_h = 9, .ofs_x = 1, .ofs_y = 1}, + {.bitmap_index = 6228, .adv_w = 240, .box_w = 15, .box_h = 15, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 6341, .adv_w = 96, .box_w = 5, .box_h = 3, .ofs_x = 1, .ofs_y = 11}, + {.bitmap_index = 6349, .adv_w = 192, .box_w = 14, .box_h = 14, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 6447, .adv_w = 226, .box_w = 15, .box_h = 14, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 6552, .adv_w = 241, .box_w = 15, .box_h = 14, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 6657, .adv_w = 111, .box_w = 6, .box_h = 14, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 6699, .adv_w = 223, .box_w = 15, .box_h = 14, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 6804, .adv_w = 246, .box_w = 17, .box_h = 14, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 6923, .adv_w = 217, .box_w = 14, .box_h = 14, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 7021, .adv_w = 64, .box_w = 8, .box_h = 14, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 7077, .adv_w = 192, .box_w = 14, .box_h = 14, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 7175, .adv_w = 192, .box_w = 11, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 7252, .adv_w = 159, .box_w = 9, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 7315, .adv_w = 192, .box_w = 14, .box_h = 14, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 7413, .adv_w = 192, .box_w = 11, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 7490, .adv_w = 176, .box_w = 11, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7567, .adv_w = 208, .box_w = 11, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 7644, .adv_w = 224, .box_w = 14, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7742, .adv_w = 80, .box_w = 3, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 7763, .adv_w = 192, .box_w = 11, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 7840, .adv_w = 192, .box_w = 12, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7924, .adv_w = 240, .box_w = 13, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 8015, .adv_w = 208, .box_w = 11, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 8092, .adv_w = 187, .box_w = 11, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 8169, .adv_w = 224, .box_w = 14, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 8267, .adv_w = 208, .box_w = 11, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 8344, .adv_w = 192, .box_w = 11, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 8421, .adv_w = 178, .box_w = 10, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 8491, .adv_w = 176, .box_w = 11, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 8568, .adv_w = 192, .box_w = 12, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 8652, .adv_w = 230, .box_w = 14, .box_h = 15, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 8757, .adv_w = 192, .box_w = 12, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 8841, .adv_w = 241, .box_w = 13, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 8932, .adv_w = 215, .box_w = 13, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 9023, .adv_w = 80, .box_w = 6, .box_h = 16, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 9071, .adv_w = 192, .box_w = 12, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 9167, .adv_w = 167, .box_w = 10, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 9237, .adv_w = 128, .box_w = 8, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 9293, .adv_w = 160, .box_w = 8, .box_h = 18, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 9365, .adv_w = 64, .box_w = 5, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 9400, .adv_w = 158, .box_w = 8, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 9456, .adv_w = 167, .box_w = 10, .box_h = 10, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 9506, .adv_w = 166, .box_w = 9, .box_h = 18, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 9587, .adv_w = 144, .box_w = 9, .box_h = 14, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 9650, .adv_w = 160, .box_w = 10, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 9720, .adv_w = 128, .box_w = 8, .box_h = 10, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 9760, .adv_w = 127, .box_w = 8, .box_h = 18, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 9832, .adv_w = 160, .box_w = 8, .box_h = 14, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 9888, .adv_w = 160, .box_w = 10, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 9958, .adv_w = 64, .box_w = 2, .box_h = 10, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 9968, .adv_w = 143, .box_w = 8, .box_h = 10, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 10008, .adv_w = 144, .box_w = 9, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 10071, .adv_w = 160, .box_w = 8, .box_h = 14, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 10127, .adv_w = 144, .box_w = 9, .box_h = 10, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 10172, .adv_w = 129, .box_w = 8, .box_h = 18, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 10244, .adv_w = 160, .box_w = 10, .box_h = 10, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 10294, .adv_w = 199, .box_w = 13, .box_h = 10, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 10359, .adv_w = 164, .box_w = 9, .box_h = 14, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 10422, .adv_w = 139, .box_w = 9, .box_h = 14, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 10485, .adv_w = 178, .box_w = 11, .box_h = 10, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 10540, .adv_w = 114, .box_w = 7, .box_h = 10, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 10575, .adv_w = 158, .box_w = 8, .box_h = 10, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 10615, .adv_w = 187, .box_w = 12, .box_h = 14, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 10699, .adv_w = 151, .box_w = 10, .box_h = 14, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 10769, .adv_w = 205, .box_w = 11, .box_h = 14, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 10846, .adv_w = 225, .box_w = 14, .box_h = 10, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 10916, .adv_w = 64, .box_w = 6, .box_h = 14, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 10958, .adv_w = 158, .box_w = 8, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 11014, .adv_w = 160, .box_w = 10, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 11084, .adv_w = 158, .box_w = 8, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 11140, .adv_w = 225, .box_w = 14, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 11238, .adv_w = 96, .box_w = 8, .box_h = 2, .ofs_x = -1, .ofs_y = 12} +}; + +/*--------------------- + * CHARACTER MAPPING + *--------------------*/ + +static const uint8_t glyph_id_ofs_list_1[] = { + 0, 0, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 0, + 13, 14, 15, 16, 0, 17, 18, 19, + 0, 0, 0, 20, 0, 21 +}; + +static const uint8_t glyph_id_ofs_list_2[] = { + 0, 0, 1, 0, 2, 3, 4, 0, + 5 +}; + +/*Collect the unicode lists and glyph_id offsets*/ +static const lv_font_fmt_txt_cmap_t cmaps[] = +{ + { + .range_start = 32, .range_length = 95, .glyph_id_start = 1, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 160, .range_length = 30, .glyph_id_start = 96, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_1, .list_length = 30, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 900, .range_length = 9, .glyph_id_start = 118, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_2, .list_length = 9, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 910, .range_length = 20, .glyph_id_start = 124, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 931, .range_length = 44, .glyph_id_start = 144, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 1012, .range_length = 1, .glyph_id_start = 188, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + } +}; + + + +/*-------------------- + * ALL CUSTOM DATA + *--------------------*/ + +#if LVGL_VERSION_MAJOR == 8 +/*Store all the custom data of the font*/ +static lv_font_fmt_txt_glyph_cache_t cache; +#endif + +#if LVGL_VERSION_MAJOR >= 8 +static const lv_font_fmt_txt_dsc_t font_dsc = { +#else +static lv_font_fmt_txt_dsc_t font_dsc = { +#endif + .glyph_bitmap = glyph_bitmap, + .glyph_dsc = glyph_dsc, + .cmaps = cmaps, + .kern_dsc = NULL, + .kern_scale = 0, + .cmap_num = 6, + .bpp = 4, + .kern_classes = 0, + .bitmap_format = 0, +#if LVGL_VERSION_MAJOR == 8 + .cache = &cache +#endif + +}; + +extern const lv_font_t lv_font_montserrat_18; + + +/*----------------- + * PUBLIC FONT + *----------------*/ + +/*Initialize a public general font descriptor*/ +#if LVGL_VERSION_MAJOR >= 8 +const lv_font_t lv_font_arial_18 = { +#else +lv_font_t lv_font_arial_18 = { +#endif + .get_glyph_dsc = lv_font_get_glyph_dsc_fmt_txt, /*Function pointer to get glyph's data*/ + .get_glyph_bitmap = lv_font_get_bitmap_fmt_txt, /*Function pointer to get glyph's bitmap*/ + .line_height = 21, /*The maximum line height required by the font*/ + .base_line = 5, /*Baseline measured from the bottom of the line*/ +#if !(LVGL_VERSION_MAJOR == 6 && LVGL_VERSION_MINOR == 0) + .subpx = LV_FONT_SUBPX_NONE, +#endif +#if LV_VERSION_CHECK(7, 4, 0) || LVGL_VERSION_MAJOR >= 8 + .underline_position = -2, + .underline_thickness = 1, +#endif + //.static_bitmap = 0, + .dsc = &font_dsc, /*The custom font data. Will be accessed by `get_glyph_bitmap/dsc` */ +#if LV_VERSION_CHECK(8, 2, 0) || LVGL_VERSION_MAJOR >= 9 + .fallback = &lv_font_montserrat_18, +#endif + .user_data = NULL, +}; + + + +#endif /*#if LV_FONT_ARIAL_18*/ diff --git a/src/fonts/lv_font_arial_20.c b/src/fonts/lv_font_arial_20.c new file mode 100644 index 0000000000..b5b9b214ef --- /dev/null +++ b/src/fonts/lv_font_arial_20.c @@ -0,0 +1,2497 @@ +/******************************************************************************* + * Size: 20 px + * Bpp: 4 + * Opts: --bpp 4 --size 20 --no-compress --stride 1 --align 1 --font Arial Greek Regular.ttf --range 32-127,160-255,880-1023 --format lvgl -o lv_font_arial_20.c + ******************************************************************************/ + +#ifdef __has_include + #if __has_include("lvgl.h") + #ifndef LV_LVGL_H_INCLUDE_SIMPLE + #define LV_LVGL_H_INCLUDE_SIMPLE + #endif + #endif +#endif + +#ifdef LV_LVGL_H_INCLUDE_SIMPLE + #include "lvgl.h" +#else + #include "lvgl/lvgl.h" +#endif + + + +#ifndef LV_FONT_ARIAL_20 +#define LV_FONT_ARIAL_20 1 +#endif + +#if LV_FONT_ARIAL_20 + +/*----------------- + * BITMAPS + *----------------*/ + +/*Store the image of the glyphs*/ +static LV_ATTRIBUTE_LARGE_CONST const uint8_t glyph_bitmap[] = { + /* U+0020 " " */ + + /* U+0021 "!" */ + 0x5f, 0xe5, 0xfe, 0x5f, 0xe4, 0xfd, 0x3f, 0xc2, + 0xfb, 0x1f, 0xa0, 0xf9, 0xf, 0x80, 0xe7, 0xd, + 0x60, 0x10, 0x1, 0x3, 0xfc, 0x3f, 0xc0, + + /* U+0022 "\"" */ + 0x1f, 0xf0, 0xdf, 0x21, 0xff, 0xd, 0xf2, 0xf, + 0xe0, 0xcf, 0x20, 0xec, 0xa, 0xf0, 0xb, 0x90, + 0x7d, 0x0, 0x22, 0x1, 0x20, + + /* U+0023 "#" */ + 0x0, 0x1, 0xf6, 0x0, 0x8f, 0x0, 0x0, 0x4f, + 0x30, 0xb, 0xb0, 0x0, 0x7, 0xf0, 0x0, 0xe8, + 0x0, 0x0, 0xbc, 0x0, 0x2f, 0x50, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xe6, 0x89, 0xfa, 0x88, 0xce, + 0x87, 0x0, 0x4f, 0x20, 0xc, 0xb0, 0x0, 0x8, + 0xf0, 0x0, 0xf8, 0x0, 0x0, 0xbc, 0x0, 0x2f, + 0x40, 0xc, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x69, + 0xfa, 0x88, 0xde, 0x88, 0x70, 0x4f, 0x20, 0xc, + 0xb0, 0x0, 0x7, 0xf0, 0x0, 0xf8, 0x0, 0x0, + 0xac, 0x0, 0x2f, 0x50, 0x0, 0xd, 0x90, 0x5, + 0xf2, 0x0, 0x0, + + /* U+0024 "$" */ + 0x0, 0x0, 0x7, 0x0, 0x0, 0x0, 0x0, 0x48, + 0xf8, 0x30, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xa0, + 0x0, 0x6f, 0xa1, 0xf2, 0xcf, 0x60, 0xc, 0xf0, + 0xf, 0x12, 0xfb, 0x0, 0xed, 0x0, 0xf1, 0x3, + 0x10, 0xc, 0xf2, 0xf, 0x10, 0x0, 0x0, 0x6f, + 0xd4, 0xf1, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xb6, + 0x0, 0x0, 0x0, 0x28, 0xff, 0xfd, 0x10, 0x0, + 0x0, 0xf, 0x3a, 0xfb, 0x0, 0x0, 0x0, 0xf1, + 0xd, 0xf1, 0x18, 0x60, 0xf, 0x10, 0x9f, 0x31, + 0xfd, 0x0, 0xf1, 0xb, 0xf1, 0xc, 0xf5, 0xf, + 0x14, 0xfc, 0x0, 0x3f, 0xfa, 0xfa, 0xff, 0x30, + 0x0, 0x2a, 0xef, 0xfb, 0x30, 0x0, 0x0, 0x0, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0xf, 0x10, 0x0, + 0x0, + + /* U+0025 "%" */ + 0x6, 0xde, 0xa1, 0x0, 0x0, 0x2f, 0x40, 0x0, + 0x4f, 0x85, 0xdc, 0x0, 0x0, 0xbc, 0x0, 0x0, + 0xae, 0x0, 0x5f, 0x20, 0x3, 0xf3, 0x0, 0x0, + 0xcc, 0x0, 0x3f, 0x40, 0xb, 0xb0, 0x0, 0x0, + 0xad, 0x0, 0x5f, 0x30, 0x4f, 0x30, 0x0, 0x0, + 0x6f, 0x51, 0xbd, 0x0, 0xca, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xd3, 0x4, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x12, 0x0, 0xd, 0x90, 0x3d, 0xfd, 0x30, + 0x0, 0x0, 0x0, 0x5f, 0x20, 0xec, 0x4b, 0xe0, + 0x0, 0x0, 0x0, 0xd9, 0x5, 0xf3, 0x2, 0xf6, + 0x0, 0x0, 0x6, 0xf1, 0x7, 0xf0, 0x0, 0xf8, + 0x0, 0x0, 0xe, 0x80, 0x7, 0xf0, 0x0, 0xf8, + 0x0, 0x0, 0x6f, 0x10, 0x5, 0xf3, 0x2, 0xf5, + 0x0, 0x0, 0xe7, 0x0, 0x0, 0xec, 0x5b, 0xe0, + 0x0, 0x7, 0xe0, 0x0, 0x0, 0x3c, 0xfc, 0x30, + + /* U+0026 "&" */ + 0x0, 0x0, 0x8d, 0xfb, 0x20, 0x0, 0x0, 0x0, + 0xcf, 0xa9, 0xfe, 0x10, 0x0, 0x0, 0x3f, 0xa0, + 0x7, 0xf6, 0x0, 0x0, 0x4, 0xf8, 0x0, 0x4f, + 0x70, 0x0, 0x0, 0xf, 0xe1, 0xb, 0xf2, 0x0, + 0x0, 0x0, 0x7f, 0xcc, 0xf6, 0x0, 0x0, 0x0, + 0x2, 0xef, 0xf3, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xdf, 0x80, 0x0, 0x0, 0x5, 0xfd, 0x12, 0xff, + 0x41, 0xfa, 0x0, 0xef, 0x20, 0x4, 0xfe, 0x8f, + 0x80, 0x1f, 0xc0, 0x0, 0x7, 0xff, 0xf2, 0x0, + 0xfe, 0x0, 0x0, 0xc, 0xfd, 0x0, 0xb, 0xf9, + 0x0, 0x7, 0xff, 0xf9, 0x0, 0x2e, 0xfd, 0xad, + 0xfd, 0x4e, 0xf9, 0x0, 0x2a, 0xef, 0xd8, 0x0, + 0x2d, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0027 "'" */ + 0x1f, 0xe1, 0xfe, 0x1f, 0xe0, 0xeb, 0xc, 0x90, + 0x21, + + /* U+0028 "(" */ + 0x0, 0xa, 0xa0, 0x4, 0xf2, 0x0, 0xe9, 0x0, + 0x5f, 0x30, 0xd, 0xd0, 0x2, 0xf9, 0x0, 0x6f, + 0x50, 0x9, 0xf2, 0x0, 0xbf, 0x10, 0xc, 0xf0, + 0x0, 0xbf, 0x10, 0x9, 0xf2, 0x0, 0x6f, 0x50, + 0x2, 0xf9, 0x0, 0xd, 0xd0, 0x0, 0x6f, 0x30, + 0x0, 0xe9, 0x0, 0x4, 0xf2, 0x0, 0xa, 0xa0, + + /* U+0029 ")" */ + 0x1f, 0x40, 0x0, 0x7, 0xe0, 0x0, 0x0, 0xe8, + 0x0, 0x0, 0x9f, 0x10, 0x0, 0x3f, 0x70, 0x0, + 0xe, 0xc0, 0x0, 0xb, 0xf1, 0x0, 0x8, 0xf4, + 0x0, 0x7, 0xf5, 0x0, 0x6, 0xf6, 0x0, 0x7, + 0xf6, 0x0, 0x8, 0xf4, 0x0, 0xb, 0xf1, 0x0, + 0xe, 0xd0, 0x0, 0x3f, 0x70, 0x0, 0x9f, 0x10, + 0x0, 0xe8, 0x0, 0x7, 0xe1, 0x0, 0x1f, 0x50, + 0x0, + + /* U+002A "*" */ + 0x0, 0xc, 0x80, 0x0, 0x4, 0xb, 0x70, 0x40, + 0x2f, 0xed, 0xcf, 0xf0, 0x2, 0x7f, 0xf6, 0x20, + 0x0, 0xcb, 0xe9, 0x0, 0x4, 0xf2, 0x5f, 0x20, + 0x0, 0x10, 0x1, 0x0, + + /* U+002B "+" */ + 0x0, 0x0, 0xc8, 0x0, 0x0, 0x0, 0x0, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0xfa, 0x0, 0x0, 0xab, 0xbb, 0xfe, 0xbb, + 0xb6, 0xef, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xfa, + 0x0, 0x0, + + /* U+002C "," */ + 0x1, 0x4, 0xfb, 0x4f, 0xb0, 0x5a, 0xa, 0x72, + 0xa0, + + /* U+002D "-" */ + 0x4d, 0xdd, 0xdd, 0x5, 0xff, 0xff, 0xf0, + + /* U+002E "." */ + 0x1, 0x3, 0xfc, 0x3f, 0xc0, + + /* U+002F "/" */ + 0x0, 0x0, 0xf6, 0x0, 0x4, 0xf2, 0x0, 0x8, + 0xd0, 0x0, 0xd, 0x90, 0x0, 0x1f, 0x50, 0x0, + 0x5f, 0x0, 0x0, 0xac, 0x0, 0x0, 0xe7, 0x0, + 0x3, 0xf3, 0x0, 0x7, 0xe0, 0x0, 0xc, 0xa0, + 0x0, 0xf, 0x60, 0x0, 0x4f, 0x10, 0x0, 0x9d, + 0x0, 0x0, 0xd8, 0x0, 0x0, + + /* U+0030 "0" */ + 0x0, 0x7, 0xdf, 0xe8, 0x0, 0x0, 0xa, 0xfc, + 0x8c, 0xfb, 0x0, 0x4, 0xfa, 0x0, 0x9, 0xf5, + 0x0, 0xaf, 0x20, 0x0, 0x1f, 0xb0, 0xd, 0xe0, + 0x0, 0x0, 0xdf, 0x0, 0xfc, 0x0, 0x0, 0xb, + 0xf1, 0x1f, 0xb0, 0x0, 0x0, 0xaf, 0x21, 0xfa, + 0x0, 0x0, 0x9, 0xf3, 0x1f, 0xb0, 0x0, 0x0, + 0xaf, 0x20, 0xfc, 0x0, 0x0, 0xb, 0xf1, 0xd, + 0xe0, 0x0, 0x0, 0xdf, 0x0, 0xaf, 0x20, 0x0, + 0x1f, 0xb0, 0x4, 0xfa, 0x0, 0x9, 0xf5, 0x0, + 0xa, 0xfc, 0x8b, 0xfb, 0x0, 0x0, 0x7, 0xdf, + 0xe8, 0x0, 0x0, + + /* U+0031 "1" */ + 0x0, 0x0, 0xe7, 0x0, 0xa, 0xf7, 0x1, 0xbf, + 0xf7, 0x5e, 0xfb, 0xf7, 0xcd, 0x44, 0xf7, 0x40, + 0x4, 0xf7, 0x0, 0x4, 0xf7, 0x0, 0x4, 0xf7, + 0x0, 0x4, 0xf7, 0x0, 0x4, 0xf7, 0x0, 0x4, + 0xf7, 0x0, 0x4, 0xf7, 0x0, 0x4, 0xf7, 0x0, + 0x4, 0xf7, 0x0, 0x4, 0xf7, + + /* U+0032 "2" */ + 0x0, 0x19, 0xef, 0xea, 0x20, 0x0, 0x1e, 0xfb, + 0x8b, 0xfe, 0x20, 0x9, 0xf7, 0x0, 0x5, 0xfb, + 0x0, 0xee, 0x0, 0x0, 0xd, 0xf0, 0x6, 0x60, + 0x0, 0x0, 0xdf, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xd0, 0x0, 0x0, 0x0, 0xb, 0xf6, 0x0, 0x0, + 0x0, 0x9, 0xfb, 0x0, 0x0, 0x0, 0x9, 0xfc, + 0x0, 0x0, 0x0, 0xb, 0xfb, 0x0, 0x0, 0x0, + 0xb, 0xfa, 0x0, 0x0, 0x0, 0xb, 0xf9, 0x0, + 0x0, 0x0, 0x8, 0xfa, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xcc, 0xcc, 0xcc, 0xc1, 0x5f, 0xff, 0xff, + 0xff, 0xff, 0x10, + + /* U+0033 "3" */ + 0x0, 0x19, 0xdf, 0xd7, 0x0, 0x0, 0x1d, 0xfa, + 0x8c, 0xfb, 0x0, 0x8, 0xf6, 0x0, 0xa, 0xf5, + 0x0, 0x9d, 0x0, 0x0, 0x4f, 0x80, 0x0, 0x0, + 0x0, 0x7, 0xf6, 0x0, 0x0, 0x0, 0x28, 0xfd, + 0x0, 0x0, 0x0, 0x8f, 0xfe, 0x20, 0x0, 0x0, + 0x4, 0x57, 0xff, 0x40, 0x0, 0x0, 0x0, 0x3, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0xb, 0xf2, 0x6, + 0x50, 0x0, 0x0, 0xaf, 0x30, 0xfe, 0x0, 0x0, + 0xd, 0xf1, 0x9, 0xf7, 0x0, 0x8, 0xfb, 0x0, + 0x1d, 0xfb, 0x9c, 0xfd, 0x10, 0x0, 0x19, 0xef, + 0xd8, 0x0, 0x0, + + /* U+0034 "4" */ + 0x0, 0x0, 0x0, 0x8f, 0x40, 0x0, 0x0, 0x0, + 0x2f, 0xf4, 0x0, 0x0, 0x0, 0xc, 0xff, 0x40, + 0x0, 0x0, 0x7, 0xfb, 0xf4, 0x0, 0x0, 0x2, + 0xf8, 0x8f, 0x40, 0x0, 0x0, 0xcd, 0x8, 0xf4, + 0x0, 0x0, 0x6f, 0x40, 0x8f, 0x40, 0x0, 0x1f, + 0xa0, 0x8, 0xf4, 0x0, 0xb, 0xe1, 0x0, 0x8f, + 0x40, 0x6, 0xf5, 0x0, 0x8, 0xf4, 0x0, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0x37, 0xaa, 0xaa, 0xad, + 0xfc, 0xa2, 0x0, 0x0, 0x0, 0x8f, 0x40, 0x0, + 0x0, 0x0, 0x8, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0x40, 0x0, + + /* U+0035 "5" */ + 0x0, 0x8f, 0xff, 0xff, 0xfb, 0x0, 0xb, 0xfb, + 0xbb, 0xbb, 0x80, 0x0, 0xed, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xa0, 0x0, 0x0, 0x0, 0x3, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0x7b, 0xee, 0xa2, + 0x0, 0x9, 0xff, 0xca, 0xdf, 0xf3, 0x0, 0xaf, + 0x40, 0x0, 0x7f, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0x30, 0x0, 0x0, 0x0, 0x9, 0xf5, 0x2, + 0x20, 0x0, 0x0, 0x9f, 0x40, 0xfe, 0x0, 0x0, + 0xd, 0xf1, 0xb, 0xf7, 0x0, 0x6, 0xfa, 0x0, + 0x2e, 0xfb, 0x8b, 0xfd, 0x10, 0x0, 0x19, 0xef, + 0xe9, 0x10, 0x0, + + /* U+0036 "6" */ + 0x0, 0x4, 0xcf, 0xeb, 0x30, 0x0, 0x6, 0xfd, + 0x89, 0xff, 0x30, 0x2, 0xfc, 0x0, 0x3, 0xfb, + 0x0, 0x9f, 0x30, 0x0, 0x8, 0x80, 0xd, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0xfa, 0x2a, 0xef, 0xb2, + 0x0, 0x1f, 0xbe, 0xea, 0xcf, 0xf2, 0x2, 0xff, + 0xb0, 0x0, 0x6f, 0xc0, 0x2f, 0xf2, 0x0, 0x0, + 0xcf, 0x11, 0xfe, 0x0, 0x0, 0x9, 0xf3, 0xf, + 0xf0, 0x0, 0x0, 0x9f, 0x30, 0xbf, 0x30, 0x0, + 0xc, 0xf1, 0x4, 0xfb, 0x0, 0x5, 0xfa, 0x0, + 0x9, 0xfd, 0x8a, 0xfe, 0x10, 0x0, 0x6, 0xcf, + 0xea, 0x20, 0x0, + + /* U+0037 "7" */ + 0xf, 0xff, 0xff, 0xff, 0xff, 0x40, 0xcc, 0xcc, + 0xcc, 0xcf, 0xf2, 0x0, 0x0, 0x0, 0x8, 0xf6, + 0x0, 0x0, 0x0, 0x3, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0x20, 0x0, 0x0, 0x0, 0x5f, 0x90, + 0x0, 0x0, 0x0, 0xc, 0xf1, 0x0, 0x0, 0x0, + 0x4, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xaf, 0x30, + 0x0, 0x0, 0x0, 0xf, 0xd0, 0x0, 0x0, 0x0, + 0x4, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0x50, + 0x0, 0x0, 0x0, 0xc, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0xef, 0x0, 0x0, 0x0, 0x0, 0xf, 0xd0, + 0x0, 0x0, 0x0, + + /* U+0038 "8" */ + 0x0, 0x8, 0xef, 0xe9, 0x10, 0x0, 0xc, 0xfc, + 0x8b, 0xfd, 0x0, 0x5, 0xfa, 0x0, 0x8, 0xf7, + 0x0, 0x8f, 0x40, 0x0, 0x2f, 0xa0, 0x7, 0xf6, + 0x0, 0x5, 0xf9, 0x0, 0x2f, 0xf6, 0x25, 0xee, + 0x20, 0x0, 0x3d, 0xff, 0xfe, 0x20, 0x0, 0xb, + 0xf8, 0x68, 0xfe, 0x20, 0x9, 0xf4, 0x0, 0x3, + 0xfc, 0x0, 0xfd, 0x0, 0x0, 0xb, 0xf2, 0x2f, + 0xb0, 0x0, 0x0, 0x8f, 0x40, 0xfd, 0x0, 0x0, + 0xb, 0xf2, 0xb, 0xf7, 0x0, 0x5, 0xfd, 0x0, + 0x2e, 0xfc, 0x8b, 0xfe, 0x30, 0x0, 0x19, 0xef, + 0xe9, 0x20, 0x0, + + /* U+0039 "9" */ + 0x0, 0x19, 0xef, 0xd7, 0x0, 0x0, 0x1d, 0xfc, + 0x8b, 0xfb, 0x0, 0x9, 0xf9, 0x0, 0x7, 0xf6, + 0x0, 0xfe, 0x0, 0x0, 0xe, 0xd0, 0x1f, 0xb0, + 0x0, 0x0, 0xbf, 0x1, 0xfc, 0x0, 0x0, 0xc, + 0xf3, 0xe, 0xf2, 0x0, 0x1, 0xff, 0x30, 0x7f, + 0xd3, 0x3, 0xcf, 0xf4, 0x0, 0xaf, 0xff, 0xfb, + 0x9f, 0x30, 0x0, 0x48, 0x85, 0x9, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0x0, 0x9d, 0x0, 0x0, + 0x2f, 0xa0, 0x8, 0xf5, 0x0, 0xb, 0xf4, 0x0, + 0x1e, 0xfa, 0x8d, 0xf8, 0x0, 0x0, 0x1a, 0xef, + 0xc5, 0x0, 0x0, + + /* U+003A ":" */ + 0x3f, 0xc3, 0xfc, 0x1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x3, 0xfc, 0x3f, + 0xc0, + + /* U+003B ";" */ + 0x4f, 0xb4, 0xfb, 0x1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x4, 0xfb, 0x4f, + 0xb0, 0x5a, 0xa, 0x72, 0xa0, + + /* U+003C "<" */ + 0x0, 0x0, 0x0, 0x0, 0x2, 0x0, 0x0, 0x0, + 0x6, 0xd9, 0x0, 0x0, 0x18, 0xff, 0xe5, 0x0, + 0x3a, 0xff, 0xc5, 0x0, 0x5c, 0xff, 0xa3, 0x0, + 0x0, 0xef, 0xa1, 0x0, 0x0, 0x0, 0xaf, 0xfb, + 0x40, 0x0, 0x0, 0x2, 0x9f, 0xfd, 0x60, 0x0, + 0x0, 0x1, 0x7e, 0xff, 0x92, 0x0, 0x0, 0x0, + 0x5c, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x35, + + /* U+003D "=" */ + 0xef, 0xff, 0xff, 0xff, 0xf9, 0x9b, 0xbb, 0xbb, + 0xbb, 0xb6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xab, 0xbb, 0xbb, 0xbb, + 0xb6, 0xef, 0xff, 0xff, 0xff, 0xf9, + + /* U+003E ">" */ + 0x20, 0x0, 0x0, 0x0, 0x0, 0xeb, 0x40, 0x0, + 0x0, 0x0, 0x9f, 0xfd, 0x60, 0x0, 0x0, 0x1, + 0x7e, 0xfe, 0x81, 0x0, 0x0, 0x0, 0x5c, 0xff, + 0xa3, 0x0, 0x0, 0x0, 0x3d, 0xf9, 0x0, 0x0, + 0x6, 0xdf, 0xf6, 0x0, 0x28, 0xff, 0xd7, 0x0, + 0x4b, 0xff, 0xc5, 0x0, 0x0, 0xef, 0xa3, 0x0, + 0x0, 0x0, 0x71, 0x0, 0x0, 0x0, 0x0, + + /* U+003F "?" */ + 0x0, 0x19, 0xef, 0xea, 0x20, 0x0, 0x1e, 0xfc, + 0x8b, 0xff, 0x30, 0x9, 0xf8, 0x0, 0x5, 0xfd, + 0x0, 0xef, 0x0, 0x0, 0xc, 0xf1, 0x5, 0x50, + 0x0, 0x0, 0xbf, 0x10, 0x0, 0x0, 0x0, 0x2f, + 0xd0, 0x0, 0x0, 0x0, 0x2e, 0xf3, 0x0, 0x0, + 0x0, 0x2e, 0xf5, 0x0, 0x0, 0x0, 0xc, 0xf4, + 0x0, 0x0, 0x0, 0x3, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0x60, 0x0, 0x0, 0x0, 0x2, 0x52, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0x80, 0x0, 0x0, + + /* U+0040 "@" */ + 0x0, 0x0, 0x2, 0x7c, 0xef, 0xfd, 0x94, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xc9, 0x78, 0xae, + 0xfc, 0x10, 0x0, 0x0, 0xb, 0xf9, 0x10, 0x0, + 0x0, 0x6, 0xfe, 0x10, 0x0, 0xa, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xec, 0x0, 0x5, 0xf6, + 0x0, 0x2a, 0xfe, 0x80, 0xed, 0x4, 0xf6, 0x0, + 0xdb, 0x0, 0x2e, 0xf9, 0x9f, 0xaf, 0xa0, 0xb, + 0xc0, 0x4f, 0x30, 0xd, 0xf2, 0x0, 0x3f, 0xf7, + 0x0, 0x7f, 0x8, 0xe0, 0x7, 0xf7, 0x0, 0x0, + 0xcf, 0x40, 0x5, 0xf1, 0xbb, 0x0, 0xdf, 0x10, + 0x0, 0xb, 0xf0, 0x0, 0x6f, 0x1d, 0x90, 0xf, + 0xc0, 0x0, 0x0, 0xdd, 0x0, 0x9, 0xf0, 0xd9, + 0x1, 0xfb, 0x0, 0x0, 0x1f, 0xa0, 0x0, 0xea, + 0xb, 0xb0, 0xf, 0xd0, 0x0, 0x9, 0xf7, 0x0, + 0x8f, 0x30, 0x9e, 0x0, 0xcf, 0x50, 0x7, 0xff, + 0x40, 0x7f, 0x80, 0x4, 0xf5, 0x4, 0xff, 0xcd, + 0xfc, 0xfd, 0xdf, 0x90, 0x0, 0xd, 0xd1, 0x4, + 0xdf, 0xc3, 0x2d, 0xfc, 0x50, 0x3, 0x10, 0x3f, + 0xc1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1c, 0xf2, + 0x0, 0x5f, 0xe6, 0x10, 0x0, 0x0, 0x1, 0x6e, + 0xf4, 0x0, 0x0, 0x3c, 0xff, 0xca, 0x88, 0xac, + 0xff, 0xb2, 0x0, 0x0, 0x0, 0x4, 0x8c, 0xef, + 0xfe, 0xc8, 0x30, 0x0, 0x0, + + /* U+0041 "A" */ + 0x0, 0x0, 0x0, 0xbf, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xf7, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xe, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xa0, 0x9f, 0x40, 0x0, 0x0, 0x0, 0x8, + 0xf5, 0x4, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xef, + 0x0, 0xe, 0xf1, 0x0, 0x0, 0x0, 0x4f, 0xa0, + 0x0, 0x9f, 0x70, 0x0, 0x0, 0xa, 0xf4, 0x0, + 0x3, 0xfd, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x5f, 0xc9, 0x99, 0x99, + 0xbf, 0xa0, 0x0, 0xb, 0xf4, 0x0, 0x0, 0x1, + 0xff, 0x0, 0x1, 0xfe, 0x0, 0x0, 0x0, 0xb, + 0xf6, 0x0, 0x7f, 0x80, 0x0, 0x0, 0x0, 0x5f, + 0xc0, 0xd, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xef, + 0x30, + + /* U+0042 "B" */ + 0x8f, 0xff, 0xff, 0xfd, 0x70, 0x0, 0x8f, 0xdc, + 0xcc, 0xdf, 0xfc, 0x0, 0x8f, 0x60, 0x0, 0x1, + 0xcf, 0x50, 0x8f, 0x60, 0x0, 0x0, 0x5f, 0x80, + 0x8f, 0x60, 0x0, 0x0, 0x5f, 0x70, 0x8f, 0x60, + 0x0, 0x1, 0xcf, 0x20, 0x8f, 0xdc, 0xcc, 0xdf, + 0xe4, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xf9, 0x0, + 0x8f, 0x60, 0x0, 0x14, 0xbf, 0xa0, 0x8f, 0x60, + 0x0, 0x0, 0xe, 0xf1, 0x8f, 0x60, 0x0, 0x0, + 0xb, 0xf3, 0x8f, 0x60, 0x0, 0x0, 0xd, 0xf2, + 0x8f, 0x60, 0x0, 0x0, 0x7f, 0xe0, 0x8f, 0xdc, + 0xcc, 0xce, 0xff, 0x40, 0x8f, 0xff, 0xff, 0xfe, + 0xa3, 0x0, + + /* U+0043 "C" */ + 0x0, 0x3, 0xad, 0xff, 0xc6, 0x0, 0x0, 0x8, + 0xff, 0xdb, 0xcf, 0xfb, 0x0, 0x8, 0xfd, 0x30, + 0x0, 0x1c, 0xf9, 0x2, 0xfe, 0x10, 0x0, 0x0, + 0x1e, 0xf2, 0x8f, 0x70, 0x0, 0x0, 0x0, 0x67, + 0x1c, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xf3, 0x0, 0x0, 0x0, 0x1, + 0x20, 0x7f, 0x70, 0x0, 0x0, 0x0, 0x8f, 0x81, + 0xfe, 0x10, 0x0, 0x0, 0x1e, 0xf3, 0x8, 0xfd, + 0x20, 0x0, 0x2c, 0xfa, 0x0, 0xa, 0xff, 0xcb, + 0xdf, 0xfb, 0x0, 0x0, 0x4, 0xae, 0xff, 0xc6, + 0x0, 0x0, + + /* U+0044 "D" */ + 0x6f, 0xff, 0xff, 0xfd, 0xa3, 0x0, 0x6, 0xfd, + 0xcc, 0xcd, 0xff, 0xf5, 0x0, 0x6f, 0x70, 0x0, + 0x0, 0x6f, 0xf2, 0x6, 0xf7, 0x0, 0x0, 0x0, + 0x7f, 0xa0, 0x6f, 0x70, 0x0, 0x0, 0x0, 0xff, + 0x6, 0xf7, 0x0, 0x0, 0x0, 0xb, 0xf3, 0x6f, + 0x70, 0x0, 0x0, 0x0, 0xaf, 0x56, 0xf7, 0x0, + 0x0, 0x0, 0x9, 0xf6, 0x6f, 0x70, 0x0, 0x0, + 0x0, 0xaf, 0x46, 0xf7, 0x0, 0x0, 0x0, 0xc, + 0xf3, 0x6f, 0x70, 0x0, 0x0, 0x1, 0xfe, 0x6, + 0xf7, 0x0, 0x0, 0x0, 0x8f, 0x90, 0x6f, 0x70, + 0x0, 0x0, 0x7f, 0xf2, 0x6, 0xfd, 0xcc, 0xcd, + 0xff, 0xf5, 0x0, 0x6f, 0xff, 0xff, 0xed, 0x82, + 0x0, 0x0, + + /* U+0045 "E" */ + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x6f, 0xdc, + 0xcc, 0xcc, 0xcc, 0xb0, 0x6f, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0x70, 0x0, 0x0, 0x0, 0x0, 0x6f, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xdc, 0xcc, 0xcc, + 0xcc, 0x40, 0x6f, 0xff, 0xff, 0xff, 0xff, 0x60, + 0x6f, 0x70, 0x0, 0x0, 0x0, 0x0, 0x6f, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0x70, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xdc, + 0xcc, 0xcc, 0xcc, 0xc3, 0x6f, 0xff, 0xff, 0xff, + 0xff, 0xf4, + + /* U+0046 "F" */ + 0x6f, 0xff, 0xff, 0xff, 0xff, 0x46, 0xfe, 0xcc, + 0xcc, 0xcc, 0xc3, 0x6f, 0x80, 0x0, 0x0, 0x0, + 0x6, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x6f, 0x80, + 0x0, 0x0, 0x0, 0x6, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xec, 0xcc, 0xcc, 0xc2, 0x6, 0xff, + 0xff, 0xff, 0xff, 0x30, 0x6f, 0x80, 0x0, 0x0, + 0x0, 0x6, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0x80, 0x0, 0x0, 0x0, 0x6, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0x80, 0x0, 0x0, 0x0, 0x6, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x6f, 0x80, 0x0, + 0x0, 0x0, 0x0, + + /* U+0047 "G" */ + 0x0, 0x2, 0x8d, 0xff, 0xea, 0x40, 0x0, 0x0, + 0x6f, 0xfe, 0xbb, 0xdf, 0xf8, 0x0, 0x5, 0xfe, + 0x40, 0x0, 0x3, 0xef, 0x50, 0x1f, 0xf2, 0x0, + 0x0, 0x0, 0x3f, 0xc0, 0x7f, 0x90, 0x0, 0x0, + 0x0, 0x8, 0x60, 0xbf, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0x0, 0x0, 0x9, 0xcc, 0xcc, 0xc3, + 0xef, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf4, 0xcf, + 0x30, 0x0, 0x0, 0x0, 0x9, 0xf4, 0x7f, 0x90, + 0x0, 0x0, 0x0, 0x9, 0xf4, 0x1f, 0xf3, 0x0, + 0x0, 0x0, 0xa, 0xf4, 0x5, 0xff, 0x70, 0x0, + 0x3, 0xaf, 0xf3, 0x0, 0x6f, 0xff, 0xdc, 0xef, + 0xfe, 0x40, 0x0, 0x1, 0x8c, 0xff, 0xeb, 0x60, + 0x0, + + /* U+0048 "H" */ + 0x6f, 0x80, 0x0, 0x0, 0x1, 0xfd, 0x6f, 0x80, + 0x0, 0x0, 0x1, 0xfd, 0x6f, 0x80, 0x0, 0x0, + 0x1, 0xfd, 0x6f, 0x80, 0x0, 0x0, 0x1, 0xfd, + 0x6f, 0x80, 0x0, 0x0, 0x1, 0xfd, 0x6f, 0x80, + 0x0, 0x0, 0x1, 0xfd, 0x6f, 0xec, 0xcc, 0xcc, + 0xcc, 0xfd, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x6f, 0x80, 0x0, 0x0, 0x1, 0xfd, 0x6f, 0x80, + 0x0, 0x0, 0x1, 0xfd, 0x6f, 0x80, 0x0, 0x0, + 0x1, 0xfd, 0x6f, 0x80, 0x0, 0x0, 0x1, 0xfd, + 0x6f, 0x80, 0x0, 0x0, 0x1, 0xfd, 0x6f, 0x80, + 0x0, 0x0, 0x1, 0xfd, 0x6f, 0x80, 0x0, 0x0, + 0x1, 0xfd, + + /* U+0049 "I" */ + 0x2f, 0xb2, 0xfb, 0x2f, 0xb2, 0xfb, 0x2f, 0xb2, + 0xfb, 0x2f, 0xb2, 0xfb, 0x2f, 0xb2, 0xfb, 0x2f, + 0xb2, 0xfb, 0x2f, 0xb2, 0xfb, 0x2f, 0xb0, + + /* U+004A "J" */ + 0x0, 0x0, 0x0, 0x7f, 0x70, 0x0, 0x0, 0x7, + 0xf7, 0x0, 0x0, 0x0, 0x7f, 0x70, 0x0, 0x0, + 0x7, 0xf7, 0x0, 0x0, 0x0, 0x7f, 0x70, 0x0, + 0x0, 0x7, 0xf7, 0x0, 0x0, 0x0, 0x7f, 0x70, + 0x0, 0x0, 0x7, 0xf7, 0x0, 0x0, 0x0, 0x7f, + 0x70, 0x0, 0x0, 0x7, 0xf7, 0x39, 0x30, 0x0, + 0x7f, 0x65, 0xf7, 0x0, 0x9, 0xf5, 0x2f, 0xd1, + 0x1, 0xef, 0x20, 0xbf, 0xfc, 0xff, 0xa0, 0x0, + 0x9e, 0xfd, 0x70, 0x0, + + /* U+004B "K" */ + 0x8f, 0x60, 0x0, 0x0, 0x1e, 0xf8, 0x8, 0xf6, + 0x0, 0x0, 0x1d, 0xf9, 0x0, 0x8f, 0x60, 0x0, + 0x1d, 0xf9, 0x0, 0x8, 0xf6, 0x0, 0xc, 0xf9, + 0x0, 0x0, 0x8f, 0x60, 0xc, 0xf9, 0x0, 0x0, + 0x8, 0xf6, 0xb, 0xf9, 0x0, 0x0, 0x0, 0x8f, + 0x6b, 0xff, 0x50, 0x0, 0x0, 0x8, 0xfe, 0xfb, + 0xfe, 0x10, 0x0, 0x0, 0x8f, 0xfa, 0x8, 0xfb, + 0x0, 0x0, 0x8, 0xfa, 0x0, 0xd, 0xf7, 0x0, + 0x0, 0x8f, 0x60, 0x0, 0x3f, 0xf2, 0x0, 0x8, + 0xf6, 0x0, 0x0, 0x8f, 0xd0, 0x0, 0x8f, 0x60, + 0x0, 0x0, 0xdf, 0x80, 0x8, 0xf6, 0x0, 0x0, + 0x3, 0xff, 0x40, 0x8f, 0x60, 0x0, 0x0, 0x8, + 0xfe, 0x10, + + /* U+004C "L" */ + 0x8f, 0x60, 0x0, 0x0, 0x0, 0x8f, 0x60, 0x0, + 0x0, 0x0, 0x8f, 0x60, 0x0, 0x0, 0x0, 0x8f, + 0x60, 0x0, 0x0, 0x0, 0x8f, 0x60, 0x0, 0x0, + 0x0, 0x8f, 0x60, 0x0, 0x0, 0x0, 0x8f, 0x60, + 0x0, 0x0, 0x0, 0x8f, 0x60, 0x0, 0x0, 0x0, + 0x8f, 0x60, 0x0, 0x0, 0x0, 0x8f, 0x60, 0x0, + 0x0, 0x0, 0x8f, 0x60, 0x0, 0x0, 0x0, 0x8f, + 0x60, 0x0, 0x0, 0x0, 0x8f, 0x60, 0x0, 0x0, + 0x0, 0x8f, 0xdc, 0xcc, 0xcc, 0xc5, 0x8f, 0xff, + 0xff, 0xff, 0xf7, + + /* U+004D "M" */ + 0x8f, 0xf8, 0x0, 0x0, 0x0, 0x8, 0xff, 0x28, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0xdf, 0xf2, 0x8f, + 0xef, 0x20, 0x0, 0x0, 0x3f, 0xff, 0x28, 0xf9, + 0xf7, 0x0, 0x0, 0x8, 0xfb, 0xf2, 0x8f, 0x5e, + 0xc0, 0x0, 0x0, 0xda, 0xaf, 0x28, 0xf5, 0x9f, + 0x10, 0x0, 0x3f, 0x5a, 0xf2, 0x8f, 0x54, 0xf6, + 0x0, 0x8, 0xf0, 0xaf, 0x28, 0xf5, 0xf, 0xc0, + 0x0, 0xda, 0xa, 0xf2, 0x8f, 0x50, 0xaf, 0x10, + 0x2f, 0x50, 0xaf, 0x28, 0xf5, 0x5, 0xf6, 0x8, + 0xf0, 0xa, 0xf2, 0x8f, 0x50, 0xf, 0xb0, 0xda, + 0x0, 0xaf, 0x28, 0xf5, 0x0, 0xaf, 0x3f, 0x50, + 0xa, 0xf2, 0x8f, 0x50, 0x5, 0xfc, 0xf0, 0x0, + 0xaf, 0x28, 0xf5, 0x0, 0xf, 0xfa, 0x0, 0xa, + 0xf2, 0x8f, 0x50, 0x0, 0xbf, 0x50, 0x0, 0xaf, + 0x20, + + /* U+004E "N" */ + 0x6f, 0xd0, 0x0, 0x0, 0x0, 0xfd, 0x6f, 0xf7, + 0x0, 0x0, 0x0, 0xfd, 0x6f, 0xff, 0x20, 0x0, + 0x0, 0xfd, 0x6f, 0xcf, 0xc0, 0x0, 0x0, 0xfd, + 0x6f, 0x6c, 0xf6, 0x0, 0x0, 0xfd, 0x6f, 0x62, + 0xff, 0x10, 0x0, 0xfd, 0x6f, 0x60, 0x8f, 0xa0, + 0x0, 0xfd, 0x6f, 0x60, 0xd, 0xf5, 0x0, 0xfd, + 0x6f, 0x60, 0x3, 0xfe, 0x0, 0xfd, 0x6f, 0x60, + 0x0, 0x9f, 0x90, 0xfd, 0x6f, 0x60, 0x0, 0xe, + 0xf3, 0xfd, 0x6f, 0x60, 0x0, 0x5, 0xfd, 0xfd, + 0x6f, 0x60, 0x0, 0x0, 0xaf, 0xfd, 0x6f, 0x60, + 0x0, 0x0, 0x1f, 0xfd, 0x6f, 0x60, 0x0, 0x0, + 0x6, 0xfd, + + /* U+004F "O" */ + 0x0, 0x0, 0x39, 0xdf, 0xec, 0x70, 0x0, 0x0, + 0x0, 0x8f, 0xfd, 0xbc, 0xff, 0xe2, 0x0, 0x0, + 0x7f, 0xe4, 0x0, 0x0, 0x8f, 0xe1, 0x0, 0x2f, + 0xe1, 0x0, 0x0, 0x0, 0x8f, 0xa0, 0x9, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xef, 0x20, 0xdf, 0x20, + 0x0, 0x0, 0x0, 0x9, 0xf6, 0xf, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0x80, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xf9, 0xf, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0x80, 0xdf, 0x10, 0x0, 0x0, + 0x0, 0x9, 0xf6, 0x8, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0xef, 0x20, 0x2f, 0xe1, 0x0, 0x0, 0x0, + 0x7f, 0xb0, 0x0, 0x7f, 0xd3, 0x0, 0x0, 0x8f, + 0xe1, 0x0, 0x0, 0x7f, 0xfd, 0xbb, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x3a, 0xef, 0xfc, 0x70, 0x0, + 0x0, + + /* U+0050 "P" */ + 0x7f, 0xff, 0xff, 0xfe, 0xb5, 0x0, 0x7f, 0xdc, + 0xcc, 0xcd, 0xff, 0x70, 0x7f, 0x70, 0x0, 0x0, + 0x4f, 0xf1, 0x7f, 0x70, 0x0, 0x0, 0xa, 0xf5, + 0x7f, 0x70, 0x0, 0x0, 0x8, 0xf7, 0x7f, 0x70, + 0x0, 0x0, 0xb, 0xf5, 0x7f, 0x70, 0x0, 0x0, + 0x6f, 0xf1, 0x7f, 0xdc, 0xcc, 0xce, 0xff, 0x60, + 0x7f, 0xff, 0xff, 0xfe, 0xa4, 0x0, 0x7f, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0x70, 0x0, 0x0, 0x0, 0x0, 0x7f, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0x70, 0x0, 0x0, + 0x0, 0x0, + + /* U+0051 "Q" */ + 0x0, 0x0, 0x39, 0xdf, 0xfc, 0x70, 0x0, 0x0, + 0x0, 0x8f, 0xfd, 0xbc, 0xff, 0xd2, 0x0, 0x0, + 0x7f, 0xd4, 0x0, 0x0, 0x8f, 0xe1, 0x0, 0x2f, + 0xe1, 0x0, 0x0, 0x0, 0x8f, 0xa0, 0x9, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xef, 0x10, 0xdf, 0x10, + 0x0, 0x0, 0x0, 0x9, 0xf6, 0xf, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0x80, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xf9, 0xf, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0x80, 0xdf, 0x20, 0x0, 0x0, + 0x0, 0x9, 0xf6, 0x8, 0xf7, 0x0, 0x0, 0x20, + 0x0, 0xef, 0x20, 0x2f, 0xe1, 0x0, 0xe, 0xd3, + 0x7f, 0xa0, 0x0, 0x7f, 0xd3, 0x0, 0x5d, 0xff, + 0xe1, 0x0, 0x0, 0x8f, 0xfd, 0xbb, 0xff, 0xfd, + 0x20, 0x0, 0x0, 0x3a, 0xef, 0xec, 0x64, 0xef, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x87, + + /* U+0052 "R" */ + 0x6f, 0xff, 0xff, 0xff, 0xea, 0x30, 0x0, 0x6f, + 0xda, 0xaa, 0xaa, 0xdf, 0xf2, 0x0, 0x6f, 0x80, + 0x0, 0x0, 0x9, 0xfa, 0x0, 0x6f, 0x80, 0x0, + 0x0, 0x1, 0xff, 0x0, 0x6f, 0x80, 0x0, 0x0, + 0x0, 0xff, 0x0, 0x6f, 0x80, 0x0, 0x0, 0x3, + 0xfd, 0x0, 0x6f, 0x80, 0x0, 0x1, 0x5e, 0xf7, + 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x6f, 0xdb, 0xbc, 0xff, 0x92, 0x0, 0x0, 0x6f, + 0x80, 0x0, 0x2e, 0xf6, 0x0, 0x0, 0x6f, 0x80, + 0x0, 0x2, 0xff, 0x40, 0x0, 0x6f, 0x80, 0x0, + 0x0, 0x6f, 0xe1, 0x0, 0x6f, 0x80, 0x0, 0x0, + 0xc, 0xf9, 0x0, 0x6f, 0x80, 0x0, 0x0, 0x2, + 0xff, 0x40, 0x6f, 0x80, 0x0, 0x0, 0x0, 0x7f, + 0xd0, + + /* U+0053 "S" */ + 0x0, 0x4, 0xbe, 0xfe, 0xb5, 0x0, 0x0, 0x8, + 0xff, 0xdc, 0xdf, 0xfa, 0x0, 0x3, 0xfd, 0x20, + 0x0, 0x2d, 0xf6, 0x0, 0x7f, 0x50, 0x0, 0x0, + 0x3f, 0xb0, 0x7, 0xf6, 0x0, 0x0, 0x0, 0x75, + 0x0, 0x2f, 0xf7, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xd9, 0x50, 0x0, 0x0, 0x0, 0x28, + 0xdf, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x15, + 0xaf, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, + 0xf1, 0xf, 0xc0, 0x0, 0x0, 0x0, 0x9f, 0x40, + 0xdf, 0x30, 0x0, 0x0, 0xb, 0xf3, 0x6, 0xfe, + 0x50, 0x0, 0x8, 0xfd, 0x0, 0x9, 0xff, 0xfd, + 0xdf, 0xfe, 0x20, 0x0, 0x4, 0xae, 0xff, 0xd8, + 0x10, 0x0, + + /* U+0054 "T" */ + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x6c, 0xcc, + 0xcf, 0xfc, 0xcc, 0xc9, 0x0, 0x0, 0xd, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xf0, + 0x0, 0x0, + + /* U+0055 "U" */ + 0x6f, 0x70, 0x0, 0x0, 0x0, 0xfd, 0x6f, 0x70, + 0x0, 0x0, 0x0, 0xfd, 0x6f, 0x70, 0x0, 0x0, + 0x0, 0xfd, 0x6f, 0x70, 0x0, 0x0, 0x0, 0xfd, + 0x6f, 0x70, 0x0, 0x0, 0x0, 0xfd, 0x6f, 0x70, + 0x0, 0x0, 0x0, 0xfd, 0x6f, 0x70, 0x0, 0x0, + 0x0, 0xfd, 0x6f, 0x70, 0x0, 0x0, 0x0, 0xfd, + 0x6f, 0x70, 0x0, 0x0, 0x0, 0xfd, 0x5f, 0x80, + 0x0, 0x0, 0x1, 0xfc, 0x4f, 0xa0, 0x0, 0x0, + 0x3, 0xfb, 0x1f, 0xe0, 0x0, 0x0, 0x8, 0xf8, + 0xa, 0xfb, 0x10, 0x0, 0x5f, 0xf2, 0x2, 0xef, + 0xfd, 0xce, 0xff, 0x60, 0x0, 0x18, 0xdf, 0xfd, + 0xa3, 0x0, + + /* U+0056 "V" */ + 0xbf, 0x50, 0x0, 0x0, 0x0, 0xe, 0xf0, 0x5f, + 0xa0, 0x0, 0x0, 0x0, 0x4f, 0xa0, 0xf, 0xf0, + 0x0, 0x0, 0x0, 0xaf, 0x40, 0x9, 0xf5, 0x0, + 0x0, 0x0, 0xfe, 0x0, 0x3, 0xfb, 0x0, 0x0, + 0x5, 0xf8, 0x0, 0x0, 0xdf, 0x0, 0x0, 0xb, + 0xf2, 0x0, 0x0, 0x8f, 0x50, 0x0, 0x1f, 0xc0, + 0x0, 0x0, 0x2f, 0xb0, 0x0, 0x6f, 0x60, 0x0, + 0x0, 0xc, 0xf1, 0x0, 0xcf, 0x0, 0x0, 0x0, + 0x6, 0xf6, 0x1, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0xfb, 0x7, 0xf4, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0x1c, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0x7f, + 0x80, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xfc, 0x0, 0x0, + 0x0, + + /* U+0057 "W" */ + 0xaf, 0x40, 0x0, 0x0, 0xdf, 0xb0, 0x0, 0x0, + 0x6f, 0x76, 0xf7, 0x0, 0x0, 0x1f, 0xff, 0x0, + 0x0, 0xa, 0xf3, 0x2f, 0xb0, 0x0, 0x6, 0xfa, + 0xf4, 0x0, 0x0, 0xef, 0x0, 0xee, 0x0, 0x0, + 0xaf, 0x3f, 0x80, 0x0, 0x1f, 0xb0, 0xa, 0xf2, + 0x0, 0xe, 0xb0, 0xec, 0x0, 0x5, 0xf6, 0x0, + 0x6f, 0x50, 0x2, 0xf7, 0xa, 0xf1, 0x0, 0x9f, + 0x20, 0x2, 0xf9, 0x0, 0x7f, 0x30, 0x6f, 0x50, + 0xc, 0xe0, 0x0, 0xe, 0xc0, 0xb, 0xe0, 0x1, + 0xf9, 0x0, 0xfa, 0x0, 0x0, 0xaf, 0x0, 0xfa, + 0x0, 0xd, 0xd0, 0x4f, 0x60, 0x0, 0x6, 0xf4, + 0x4f, 0x60, 0x0, 0x9f, 0x17, 0xf1, 0x0, 0x0, + 0x2f, 0x78, 0xf2, 0x0, 0x5, 0xf5, 0xbd, 0x0, + 0x0, 0x0, 0xea, 0xbd, 0x0, 0x0, 0x1f, 0x8f, + 0x90, 0x0, 0x0, 0xa, 0xdf, 0x90, 0x0, 0x0, + 0xcd, 0xf5, 0x0, 0x0, 0x0, 0x6f, 0xf5, 0x0, + 0x0, 0x8, 0xff, 0x10, 0x0, 0x0, 0x2, 0xff, + 0x10, 0x0, 0x0, 0x4f, 0xd0, 0x0, 0x0, + + /* U+0058 "X" */ + 0xd, 0xf5, 0x0, 0x0, 0x0, 0x9f, 0x70, 0x3, + 0xfe, 0x10, 0x0, 0x5, 0xfc, 0x0, 0x0, 0x8f, + 0xa0, 0x0, 0x1e, 0xe1, 0x0, 0x0, 0xd, 0xf5, + 0x0, 0xcf, 0x50, 0x0, 0x0, 0x3, 0xfe, 0x17, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xbf, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xef, 0xc0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0x2c, 0xf7, 0x0, 0x0, 0x0, 0xb, + 0xf7, 0x2, 0xff, 0x20, 0x0, 0x0, 0x6f, 0xc0, + 0x0, 0x7f, 0xc0, 0x0, 0x2, 0xff, 0x20, 0x0, + 0xc, 0xf8, 0x0, 0xd, 0xf6, 0x0, 0x0, 0x2, + 0xff, 0x30, 0x8f, 0xb0, 0x0, 0x0, 0x0, 0x7f, + 0xd0, + + /* U+0059 "Y" */ + 0x9f, 0xa0, 0x0, 0x0, 0x0, 0x5f, 0xd0, 0x1e, + 0xf4, 0x0, 0x0, 0x0, 0xef, 0x30, 0x5, 0xfe, + 0x0, 0x0, 0x9, 0xf8, 0x0, 0x0, 0xbf, 0x80, + 0x0, 0x3f, 0xd0, 0x0, 0x0, 0x1f, 0xf2, 0x0, + 0xdf, 0x30, 0x0, 0x0, 0x6, 0xfb, 0x7, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0x6f, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xf7, 0x0, 0x0, + 0x0, + + /* U+005A "Z" */ + 0xd, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x9, 0xcc, + 0xcc, 0xcc, 0xcf, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xd0, 0x0, 0x0, 0x0, 0x4, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x1e, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0x80, 0x0, 0x0, 0x0, 0x8, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xe1, 0x0, 0x0, + 0x0, 0x2, 0xff, 0x40, 0x0, 0x0, 0x0, 0xc, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xb0, 0x0, + 0x0, 0x0, 0x5, 0xfd, 0x10, 0x0, 0x0, 0x0, + 0x2f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xec, + 0xcc, 0xcc, 0xcc, 0xc8, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xfb, + + /* U+005B "[" */ + 0xaf, 0xff, 0x3a, 0xf8, 0x81, 0xaf, 0x10, 0xa, + 0xf1, 0x0, 0xaf, 0x10, 0xa, 0xf1, 0x0, 0xaf, + 0x10, 0xa, 0xf1, 0x0, 0xaf, 0x10, 0xa, 0xf1, + 0x0, 0xaf, 0x10, 0xa, 0xf1, 0x0, 0xaf, 0x10, + 0xa, 0xf1, 0x0, 0xaf, 0x10, 0xa, 0xf1, 0x0, + 0xaf, 0x10, 0xa, 0xf8, 0x81, 0xaf, 0xff, 0x30, + + /* U+005C "\\" */ + 0xd8, 0x0, 0x0, 0x9d, 0x0, 0x0, 0x4f, 0x10, + 0x0, 0xf, 0x60, 0x0, 0xc, 0xa0, 0x0, 0x7, + 0xe0, 0x0, 0x3, 0xf3, 0x0, 0x0, 0xe7, 0x0, + 0x0, 0xac, 0x0, 0x0, 0x5f, 0x0, 0x0, 0x1f, + 0x50, 0x0, 0xd, 0x90, 0x0, 0x8, 0xd0, 0x0, + 0x4, 0xf2, 0x0, 0x0, 0xf6, + + /* U+005D "]" */ + 0xaf, 0xff, 0x35, 0x8c, 0xf3, 0x0, 0x8f, 0x30, + 0x8, 0xf3, 0x0, 0x8f, 0x30, 0x8, 0xf3, 0x0, + 0x8f, 0x30, 0x8, 0xf3, 0x0, 0x8f, 0x30, 0x8, + 0xf3, 0x0, 0x8f, 0x30, 0x8, 0xf3, 0x0, 0x8f, + 0x30, 0x8, 0xf3, 0x0, 0x8f, 0x30, 0x8, 0xf3, + 0x0, 0x8f, 0x35, 0x8c, 0xf3, 0xaf, 0xff, 0x30, + + /* U+005E "^" */ + 0x0, 0x4, 0xf9, 0x0, 0x0, 0x0, 0xaf, 0xf1, + 0x0, 0x0, 0x1f, 0xaf, 0x70, 0x0, 0x8, 0xf1, + 0xbe, 0x0, 0x0, 0xeb, 0x5, 0xf5, 0x0, 0x6f, + 0x40, 0xe, 0xc0, 0xd, 0xe0, 0x0, 0x8f, 0x34, + 0xf8, 0x0, 0x1, 0xfa, + + /* U+005F "_" */ + 0x1, 0x11, 0x11, 0x11, 0x11, 0x11, 0x2, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf3, 0x4, 0x44, 0x44, + 0x44, 0x44, 0x44, 0x0, + + /* U+0060 "`" */ + 0xa, 0xd5, 0x0, 0x2e, 0xd0, 0x0, 0x4f, 0x40, + + /* U+0061 "a" */ + 0x0, 0x2a, 0xdf, 0xec, 0x50, 0x0, 0x2f, 0xfa, + 0x8a, 0xff, 0x50, 0xa, 0xf3, 0x0, 0x5, 0xfa, + 0x0, 0x46, 0x0, 0x0, 0xf, 0xb0, 0x0, 0x0, + 0x36, 0x8c, 0xfb, 0x0, 0x1a, 0xff, 0xfe, 0xaf, + 0xc0, 0xd, 0xf9, 0x41, 0x0, 0xfc, 0x2, 0xfb, + 0x0, 0x0, 0x3f, 0xc0, 0x2f, 0xc0, 0x0, 0xb, + 0xfc, 0x0, 0xcf, 0xb7, 0x8d, 0xff, 0xd0, 0x1, + 0x9e, 0xfe, 0xa2, 0xaf, 0x10, + + /* U+0062 "b" */ + 0xaf, 0x10, 0x0, 0x0, 0x0, 0xaf, 0x10, 0x0, + 0x0, 0x0, 0xaf, 0x10, 0x0, 0x0, 0x0, 0xaf, + 0x10, 0x0, 0x0, 0x0, 0xaf, 0x3a, 0xff, 0xb2, + 0x0, 0xaf, 0xed, 0x8a, 0xff, 0x20, 0xaf, 0xd0, + 0x0, 0x4f, 0xb0, 0xaf, 0x50, 0x0, 0xd, 0xf1, + 0xaf, 0x10, 0x0, 0x9, 0xf4, 0xaf, 0x0, 0x0, + 0x7, 0xf5, 0xaf, 0x0, 0x0, 0x8, 0xf4, 0xaf, + 0x20, 0x0, 0xc, 0xf1, 0xaf, 0x90, 0x0, 0x3f, + 0xa0, 0xaf, 0xf9, 0x46, 0xee, 0x10, 0xaf, 0x3b, + 0xfe, 0xa1, 0x0, + + /* U+0063 "c" */ + 0x0, 0x19, 0xef, 0xd8, 0x0, 0x1, 0xdf, 0xc8, + 0xbf, 0xc0, 0x9, 0xf7, 0x0, 0x8, 0xf5, 0xf, + 0xe0, 0x0, 0x1, 0x83, 0x2f, 0xb0, 0x0, 0x0, + 0x0, 0x3f, 0x90, 0x0, 0x0, 0x0, 0x2f, 0xa0, + 0x0, 0x0, 0x0, 0xf, 0xd0, 0x0, 0x1, 0xfa, + 0x9, 0xf5, 0x0, 0x8, 0xf6, 0x1, 0xdf, 0xa8, + 0xbf, 0xb0, 0x0, 0x19, 0xef, 0xe8, 0x0, + + /* U+0064 "d" */ + 0x0, 0x0, 0x0, 0x0, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0xfb, 0x0, 0x2a, 0xef, 0xb2, + 0xfb, 0x1, 0xef, 0xa8, 0xde, 0xfb, 0xa, 0xf5, + 0x0, 0xc, 0xfb, 0xf, 0xd0, 0x0, 0x4, 0xfb, + 0x3f, 0xa0, 0x0, 0x0, 0xfb, 0x4f, 0x80, 0x0, + 0x0, 0xeb, 0x3f, 0xa0, 0x0, 0x0, 0xfb, 0xf, + 0xd0, 0x0, 0x2, 0xfb, 0x9, 0xf6, 0x0, 0xb, + 0xfb, 0x1, 0xdf, 0xa8, 0xde, 0xfb, 0x0, 0x19, + 0xef, 0xb2, 0xeb, + + /* U+0065 "e" */ + 0x0, 0x8, 0xdf, 0xe9, 0x10, 0x0, 0xd, 0xfc, + 0x8a, 0xfe, 0x10, 0x8, 0xf8, 0x0, 0x4, 0xfa, + 0x0, 0xee, 0x0, 0x0, 0xb, 0xf1, 0x2f, 0xd8, + 0x88, 0x88, 0xcf, 0x33, 0xff, 0xff, 0xff, 0xff, + 0xf5, 0x2f, 0xa0, 0x0, 0x0, 0x0, 0x0, 0xfe, + 0x0, 0x0, 0x6, 0x71, 0x9, 0xf8, 0x0, 0x3, + 0xfe, 0x0, 0x1d, 0xfc, 0x8a, 0xff, 0x40, 0x0, + 0x18, 0xdf, 0xea, 0x30, 0x0, + + /* U+0066 "f" */ + 0x0, 0x5d, 0xfe, 0x10, 0x1f, 0xfb, 0xb0, 0x4, + 0xf9, 0x0, 0x0, 0x4f, 0x70, 0x0, 0xdf, 0xff, + 0xf7, 0x5, 0x9f, 0xa6, 0x30, 0x4, 0xf7, 0x0, + 0x0, 0x4f, 0x70, 0x0, 0x4, 0xf7, 0x0, 0x0, + 0x4f, 0x70, 0x0, 0x4, 0xf7, 0x0, 0x0, 0x4f, + 0x70, 0x0, 0x4, 0xf7, 0x0, 0x0, 0x4f, 0x70, + 0x0, 0x4, 0xf7, 0x0, 0x0, + + /* U+0067 "g" */ + 0x0, 0x2a, 0xef, 0xb3, 0xcd, 0x1, 0xef, 0xa8, + 0xdf, 0xed, 0xa, 0xf5, 0x0, 0xb, 0xfd, 0xf, + 0xd0, 0x0, 0x2, 0xfd, 0x3f, 0x90, 0x0, 0x0, + 0xed, 0x4f, 0x80, 0x0, 0x0, 0xdd, 0x3f, 0x80, + 0x0, 0x0, 0xed, 0xf, 0xc0, 0x0, 0x1, 0xfd, + 0xa, 0xf5, 0x0, 0xa, 0xfd, 0x1, 0xef, 0xb9, + 0xde, 0xfd, 0x0, 0x2a, 0xef, 0xb2, 0xfc, 0x2, + 0x0, 0x0, 0x1, 0xfa, 0xe, 0xe0, 0x0, 0x7, + 0xf6, 0x7, 0xfd, 0x88, 0xbf, 0xc0, 0x0, 0x6c, + 0xff, 0xd7, 0x0, + + /* U+0068 "h" */ + 0xaf, 0x10, 0x0, 0x0, 0xa, 0xf1, 0x0, 0x0, + 0x0, 0xaf, 0x10, 0x0, 0x0, 0xa, 0xf1, 0x0, + 0x0, 0x0, 0xaf, 0x29, 0xef, 0xc4, 0xa, 0xfe, + 0xea, 0xbf, 0xf3, 0xaf, 0xc1, 0x0, 0x6f, 0x9a, + 0xf4, 0x0, 0x0, 0xfc, 0xaf, 0x20, 0x0, 0xf, + 0xca, 0xf1, 0x0, 0x0, 0xfc, 0xaf, 0x10, 0x0, + 0xf, 0xca, 0xf1, 0x0, 0x0, 0xfc, 0xaf, 0x10, + 0x0, 0xf, 0xca, 0xf1, 0x0, 0x0, 0xfc, 0xaf, + 0x10, 0x0, 0xf, 0xc0, + + /* U+0069 "i" */ + 0xaf, 0x1a, 0xf1, 0x1, 0x0, 0x0, 0xaf, 0x1a, + 0xf1, 0xaf, 0x1a, 0xf1, 0xaf, 0x1a, 0xf1, 0xaf, + 0x1a, 0xf1, 0xaf, 0x1a, 0xf1, 0xaf, 0x10, + + /* U+006A "j" */ + 0x0, 0xaf, 0x10, 0xa, 0xf1, 0x0, 0x11, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0x10, 0xa, 0xf1, 0x0, + 0xaf, 0x10, 0xa, 0xf1, 0x0, 0xaf, 0x10, 0xa, + 0xf1, 0x0, 0xaf, 0x10, 0xa, 0xf1, 0x0, 0xaf, + 0x10, 0xa, 0xf1, 0x0, 0xaf, 0x10, 0xa, 0xf1, + 0x0, 0xcf, 0x6, 0xaf, 0xc0, 0xbf, 0xc3, 0x0, + + /* U+006B "k" */ + 0xaf, 0x10, 0x0, 0x0, 0xa, 0xf1, 0x0, 0x0, + 0x0, 0xaf, 0x10, 0x0, 0x0, 0xa, 0xf1, 0x0, + 0x0, 0x0, 0xaf, 0x10, 0x3, 0xfe, 0x2a, 0xf1, + 0x3, 0xfe, 0x20, 0xaf, 0x12, 0xee, 0x20, 0xa, + 0xf3, 0xee, 0x30, 0x0, 0xaf, 0xef, 0xd0, 0x0, + 0xa, 0xff, 0xbf, 0x70, 0x0, 0xaf, 0x41, 0xef, + 0x20, 0xa, 0xf1, 0x6, 0xfb, 0x0, 0xaf, 0x10, + 0xc, 0xf5, 0xa, 0xf1, 0x0, 0x2f, 0xe1, 0xaf, + 0x10, 0x0, 0x8f, 0x90, + + /* U+006C "l" */ + 0xbf, 0x1b, 0xf1, 0xbf, 0x1b, 0xf1, 0xbf, 0x1b, + 0xf1, 0xbf, 0x1b, 0xf1, 0xbf, 0x1b, 0xf1, 0xbf, + 0x1b, 0xf1, 0xbf, 0x1b, 0xf1, 0xbf, 0x10, + + /* U+006D "m" */ + 0xbe, 0x2b, 0xff, 0xb2, 0x19, 0xef, 0xb2, 0xb, + 0xfe, 0xa6, 0x9f, 0xdd, 0xb6, 0x8f, 0xd0, 0xbf, + 0x90, 0x0, 0xcf, 0xb0, 0x0, 0x9f, 0x3b, 0xf3, + 0x0, 0x9, 0xf5, 0x0, 0x7, 0xf5, 0xbf, 0x10, + 0x0, 0x8f, 0x40, 0x0, 0x6f, 0x5b, 0xf1, 0x0, + 0x8, 0xf3, 0x0, 0x6, 0xf5, 0xbf, 0x10, 0x0, + 0x8f, 0x30, 0x0, 0x6f, 0x5b, 0xf1, 0x0, 0x8, + 0xf3, 0x0, 0x6, 0xf5, 0xbf, 0x10, 0x0, 0x8f, + 0x30, 0x0, 0x6f, 0x5b, 0xf1, 0x0, 0x8, 0xf3, + 0x0, 0x6, 0xf5, 0xbf, 0x10, 0x0, 0x8f, 0x30, + 0x0, 0x6f, 0x50, + + /* U+006E "n" */ + 0xaf, 0x1a, 0xef, 0xc4, 0xa, 0xfe, 0xb6, 0x7e, + 0xf3, 0xaf, 0xa0, 0x0, 0x4f, 0x9a, 0xf4, 0x0, + 0x0, 0xfb, 0xaf, 0x20, 0x0, 0xf, 0xca, 0xf1, + 0x0, 0x0, 0xfc, 0xaf, 0x10, 0x0, 0xf, 0xca, + 0xf1, 0x0, 0x0, 0xfc, 0xaf, 0x10, 0x0, 0xf, + 0xca, 0xf1, 0x0, 0x0, 0xfc, 0xaf, 0x10, 0x0, + 0xf, 0xc0, + + /* U+006F "o" */ + 0x0, 0x18, 0xdf, 0xea, 0x20, 0x0, 0x1d, 0xfb, + 0x8b, 0xfe, 0x20, 0xa, 0xf7, 0x0, 0x5, 0xfc, + 0x0, 0xfd, 0x0, 0x0, 0xc, 0xf2, 0x3f, 0xa0, + 0x0, 0x0, 0x8f, 0x54, 0xf8, 0x0, 0x0, 0x6, + 0xf6, 0x3f, 0xa0, 0x0, 0x0, 0x7f, 0x50, 0xfd, + 0x0, 0x0, 0xb, 0xf2, 0xa, 0xf7, 0x0, 0x5, + 0xfc, 0x0, 0x1e, 0xfb, 0x8a, 0xfe, 0x20, 0x0, + 0x19, 0xef, 0xea, 0x20, 0x0, + + /* U+0070 "p" */ + 0xaf, 0x2b, 0xff, 0xb2, 0x0, 0xaf, 0xfa, 0x35, + 0xdf, 0x20, 0xaf, 0xb0, 0x0, 0x2f, 0xc0, 0xaf, + 0x40, 0x0, 0xb, 0xf1, 0xaf, 0x0, 0x0, 0x8, + 0xf4, 0xaf, 0x0, 0x0, 0x7, 0xf5, 0xaf, 0x10, + 0x0, 0x8, 0xf4, 0xaf, 0x40, 0x0, 0xc, 0xf1, + 0xaf, 0xc0, 0x0, 0x5f, 0xa0, 0xaf, 0xfd, 0x8a, + 0xfe, 0x10, 0xaf, 0x3b, 0xfe, 0xa1, 0x0, 0xaf, + 0x10, 0x0, 0x0, 0x0, 0xaf, 0x10, 0x0, 0x0, + 0x0, 0xaf, 0x10, 0x0, 0x0, 0x0, 0xaf, 0x10, + 0x0, 0x0, 0x0, + + /* U+0071 "q" */ + 0x0, 0x2a, 0xef, 0xb2, 0xdb, 0x1, 0xef, 0x97, + 0xce, 0xeb, 0xa, 0xf5, 0x0, 0xb, 0xfb, 0xf, + 0xd0, 0x0, 0x4, 0xfb, 0x3f, 0xa0, 0x0, 0x0, + 0xfb, 0x3f, 0x90, 0x0, 0x0, 0xeb, 0x2f, 0xa0, + 0x0, 0x0, 0xeb, 0xf, 0xe0, 0x0, 0x2, 0xfb, + 0x8, 0xf7, 0x0, 0xa, 0xfb, 0x0, 0xdf, 0xa8, + 0xde, 0xfb, 0x0, 0x19, 0xef, 0xb3, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0xfb, + + /* U+0072 "r" */ + 0xbe, 0x3d, 0xfa, 0xbe, 0xec, 0xb8, 0xbf, 0xa0, + 0x0, 0xbf, 0x30, 0x0, 0xbf, 0x10, 0x0, 0xbf, + 0x10, 0x0, 0xbf, 0x10, 0x0, 0xbf, 0x10, 0x0, + 0xbf, 0x10, 0x0, 0xbf, 0x10, 0x0, 0xbf, 0x10, + 0x0, + + /* U+0073 "s" */ + 0x0, 0x7d, 0xfe, 0xb4, 0x0, 0x9, 0xfc, 0x89, + 0xef, 0x40, 0xf, 0xb0, 0x0, 0x2f, 0xb0, 0xf, + 0xd1, 0x0, 0x2, 0x0, 0x9, 0xff, 0xc7, 0x20, + 0x0, 0x0, 0x6c, 0xff, 0xfd, 0x30, 0x0, 0x0, + 0x16, 0xbf, 0xe0, 0x28, 0x40, 0x0, 0xa, 0xf3, + 0x1f, 0xc0, 0x0, 0xc, 0xf1, 0x8, 0xfd, 0x98, + 0xdf, 0x90, 0x0, 0x6c, 0xef, 0xc5, 0x0, + + /* U+0074 "t" */ + 0x0, 0x33, 0x0, 0x4, 0xf5, 0x0, 0x6, 0xf5, + 0x0, 0x6, 0xf5, 0x0, 0xaf, 0xff, 0xf2, 0x4a, + 0xfa, 0x60, 0x6, 0xf5, 0x0, 0x6, 0xf5, 0x0, + 0x6, 0xf5, 0x0, 0x6, 0xf5, 0x0, 0x6, 0xf5, + 0x0, 0x6, 0xf5, 0x0, 0x5, 0xf6, 0x0, 0x3, + 0xfe, 0xb2, 0x0, 0x9f, 0xf4, + + /* U+0075 "u" */ + 0xbf, 0x10, 0x0, 0xf, 0xbb, 0xf1, 0x0, 0x0, + 0xfb, 0xbf, 0x10, 0x0, 0xf, 0xbb, 0xf1, 0x0, + 0x0, 0xfb, 0xbf, 0x10, 0x0, 0xf, 0xbb, 0xf1, + 0x0, 0x0, 0xfb, 0xaf, 0x10, 0x0, 0x1f, 0xba, + 0xf2, 0x0, 0x3, 0xfb, 0x8f, 0x70, 0x0, 0xbf, + 0xb2, 0xff, 0xba, 0xed, 0xeb, 0x3, 0xcf, 0xe9, + 0x1d, 0xb0, + + /* U+0076 "v" */ + 0x9f, 0x40, 0x0, 0x3, 0xf9, 0x3f, 0x90, 0x0, + 0x9, 0xf3, 0xd, 0xe0, 0x0, 0xe, 0xd0, 0x7, + 0xf4, 0x0, 0x3f, 0x80, 0x2, 0xfa, 0x0, 0x9f, + 0x20, 0x0, 0xcf, 0x0, 0xec, 0x0, 0x0, 0x6f, + 0x44, 0xf7, 0x0, 0x0, 0x1f, 0x99, 0xf1, 0x0, + 0x0, 0xb, 0xee, 0xb0, 0x0, 0x0, 0x5, 0xff, + 0x60, 0x0, 0x0, 0x0, 0xff, 0x0, 0x0, + + /* U+0077 "w" */ + 0xcf, 0x0, 0x0, 0xcf, 0x40, 0x0, 0x8f, 0x27, + 0xf4, 0x0, 0xf, 0xf8, 0x0, 0xc, 0xe0, 0x3f, + 0x90, 0x4, 0xff, 0xc0, 0x1, 0xf9, 0x0, 0xed, + 0x0, 0x8f, 0x9f, 0x0, 0x5f, 0x40, 0x9, 0xf1, + 0xc, 0xb5, 0xf4, 0xa, 0xf0, 0x0, 0x5f, 0x50, + 0xf7, 0x1f, 0x80, 0xeb, 0x0, 0x0, 0xf9, 0x4f, + 0x30, 0xdc, 0x3f, 0x60, 0x0, 0xb, 0xd8, 0xf0, + 0x9, 0xf8, 0xf1, 0x0, 0x0, 0x7f, 0xeb, 0x0, + 0x5f, 0xfd, 0x0, 0x0, 0x2, 0xff, 0x70, 0x1, + 0xff, 0x80, 0x0, 0x0, 0xe, 0xf3, 0x0, 0xd, + 0xf3, 0x0, 0x0, + + /* U+0078 "x" */ + 0x3f, 0xe0, 0x0, 0xd, 0xf3, 0x9, 0xf8, 0x0, + 0x8f, 0x80, 0x0, 0xdf, 0x23, 0xfd, 0x0, 0x0, + 0x4f, 0xcd, 0xf2, 0x0, 0x0, 0x9, 0xff, 0x70, + 0x0, 0x0, 0x4, 0xff, 0x30, 0x0, 0x0, 0xd, + 0xff, 0xd0, 0x0, 0x0, 0x8f, 0x77, 0xf8, 0x0, + 0x3, 0xfd, 0x0, 0xdf, 0x30, 0xd, 0xf3, 0x0, + 0x3f, 0xd0, 0x8f, 0x90, 0x0, 0x9, 0xf8, + + /* U+0079 "y" */ + 0x7f, 0x60, 0x0, 0x1, 0xfa, 0x2f, 0xb0, 0x0, + 0x7, 0xf4, 0xc, 0xf1, 0x0, 0xd, 0xe0, 0x6, + 0xf7, 0x0, 0x3f, 0x80, 0x0, 0xfc, 0x0, 0x8f, + 0x30, 0x0, 0xaf, 0x20, 0xed, 0x0, 0x0, 0x4f, + 0x73, 0xf7, 0x0, 0x0, 0xe, 0xc8, 0xf1, 0x0, + 0x0, 0x8, 0xfe, 0xb0, 0x0, 0x0, 0x2, 0xff, + 0x50, 0x0, 0x0, 0x0, 0xdf, 0x0, 0x0, 0x0, + 0x1, 0xfa, 0x0, 0x0, 0x0, 0x8, 0xf3, 0x0, + 0x0, 0xc, 0xdf, 0xb0, 0x0, 0x0, 0xb, 0xfb, + 0x10, 0x0, 0x0, + + /* U+007A "z" */ + 0x3f, 0xff, 0xff, 0xff, 0xf4, 0x17, 0x77, 0x77, + 0x9f, 0xe1, 0x0, 0x0, 0x0, 0xdf, 0x30, 0x0, + 0x0, 0xa, 0xf6, 0x0, 0x0, 0x0, 0x8f, 0xa0, + 0x0, 0x0, 0x5, 0xfc, 0x0, 0x0, 0x0, 0x2f, + 0xe1, 0x0, 0x0, 0x1, 0xdf, 0x40, 0x0, 0x0, + 0xb, 0xf6, 0x0, 0x0, 0x0, 0x7f, 0xe8, 0x89, + 0x99, 0x95, 0x9f, 0xff, 0xff, 0xff, 0xf9, + + /* U+007B "{" */ + 0x0, 0x5, 0xdf, 0x30, 0x1, 0xfe, 0xa2, 0x0, + 0x4f, 0x50, 0x0, 0x6, 0xf3, 0x0, 0x0, 0x6f, + 0x30, 0x0, 0x6, 0xf3, 0x0, 0x0, 0x8f, 0x20, + 0x0, 0xd, 0xe0, 0x0, 0x4e, 0xe3, 0x0, 0x7, + 0xfb, 0x0, 0x0, 0x4, 0xfa, 0x0, 0x0, 0xa, + 0xf0, 0x0, 0x0, 0x7f, 0x20, 0x0, 0x6, 0xf3, + 0x0, 0x0, 0x6f, 0x30, 0x0, 0x5, 0xf4, 0x0, + 0x0, 0x4f, 0x50, 0x0, 0x1, 0xee, 0x92, 0x0, + 0x4, 0xdf, 0x30, + + /* U+007C "|" */ + 0x2f, 0x62, 0xf6, 0x2f, 0x62, 0xf6, 0x2f, 0x62, + 0xf6, 0x2f, 0x62, 0xf6, 0x2f, 0x62, 0xf6, 0x2f, + 0x62, 0xf6, 0x2f, 0x62, 0xf6, 0x2f, 0x62, 0xf6, + 0x2f, 0x62, 0xf6, 0x2f, 0x60, + + /* U+007D "}" */ + 0x8f, 0xc1, 0x0, 0x5, 0xbf, 0xb0, 0x0, 0x0, + 0xaf, 0x0, 0x0, 0x9, 0xf1, 0x0, 0x0, 0x9f, + 0x10, 0x0, 0x8, 0xf1, 0x0, 0x0, 0x7f, 0x30, + 0x0, 0x3, 0xf8, 0x0, 0x0, 0x7, 0xfc, 0x10, + 0x0, 0x3d, 0xf1, 0x0, 0xe, 0xc2, 0x0, 0x5, + 0xf4, 0x0, 0x0, 0x8f, 0x20, 0x0, 0x8, 0xf1, + 0x0, 0x0, 0x8f, 0x10, 0x0, 0x9, 0xf0, 0x0, + 0x0, 0xbf, 0x0, 0x5, 0xbf, 0xb0, 0x0, 0x8f, + 0xb1, 0x0, 0x0, + + /* U+007E "~" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6d, 0xfd, + 0xa5, 0x0, 0x39, 0x2f, 0xff, 0xff, 0xff, 0xff, + 0xd2, 0x91, 0x1, 0x6b, 0xef, 0xb4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+00A0 " " */ + + /* U+00A3 "£" */ + 0x0, 0x6, 0xcf, 0xeb, 0x30, 0x0, 0xa, 0xfd, + 0x99, 0xff, 0x40, 0x3, 0xfc, 0x0, 0x2, 0xfd, + 0x0, 0x7f, 0x60, 0x0, 0x9, 0xc1, 0x7, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xa0, 0x0, 0x0, + 0x0, 0x48, 0xfe, 0x88, 0x70, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x8f, 0x40, 0x0, + 0x0, 0x0, 0x7, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0x10, 0x0, 0x0, 0x0, 0x1f, 0x90, 0x0, + 0x0, 0x0, 0xb, 0xe7, 0x74, 0x10, 0x2, 0x8, + 0xff, 0xff, 0xff, 0xdc, 0xf5, 0x3b, 0x40, 0x15, + 0x9e, 0xfb, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00A4 "¤" */ + 0x1, 0x0, 0x0, 0x0, 0x1, 0x0, 0xda, 0x17, + 0xa8, 0x29, 0xe1, 0x9, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0xf, 0xe4, 0x4, 0xdf, 0x20, 0x6, 0xf5, + 0x0, 0x3, 0xf8, 0x0, 0x8f, 0x10, 0x0, 0xf, + 0xa0, 0x7, 0xf2, 0x0, 0x1, 0xf9, 0x0, 0x2f, + 0xb0, 0x0, 0xaf, 0x40, 0x4, 0xff, 0xeb, 0xef, + 0xf6, 0x0, 0xfe, 0x7d, 0xfd, 0x7d, 0xf2, 0x4, + 0x20, 0x0, 0x0, 0x15, 0x0, + + /* U+00A5 "¥" */ + 0xbf, 0x30, 0x0, 0x0, 0x3f, 0xd0, 0x3f, 0xb0, + 0x0, 0x0, 0xbf, 0x50, 0xa, 0xf4, 0x0, 0x3, + 0xfc, 0x0, 0x2, 0xfc, 0x0, 0xb, 0xf4, 0x0, + 0x0, 0x9f, 0x40, 0x3f, 0xb0, 0x0, 0x0, 0x1f, + 0xd0, 0xbf, 0x30, 0x0, 0x0, 0x8, 0xf7, 0xfa, + 0x0, 0x0, 0x28, 0x89, 0xff, 0xfa, 0x88, 0x30, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0x70, 0x1, 0x11, + 0x5f, 0x81, 0x11, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0x70, 0x14, 0x44, 0x8f, 0x94, 0x44, 0x20, + 0x0, 0x0, 0x4f, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0x70, 0x0, 0x0, 0x0, 0x0, 0x4f, 0x70, + 0x0, 0x0, + + /* U+00A6 "¦" */ + 0x2f, 0x62, 0xf6, 0x2f, 0x62, 0xf6, 0x2f, 0x62, + 0xf6, 0x2f, 0x62, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xf6, 0x2f, 0x62, 0xf6, 0x2f, 0x62, 0xf6, + 0x2f, 0x62, 0xf6, 0x2f, 0x60, + + /* U+00A7 "§" */ + 0x0, 0x8, 0xdf, 0xd7, 0x0, 0x0, 0xa, 0xfb, + 0x8c, 0xfa, 0x0, 0x1, 0xfa, 0x0, 0xc, 0xf2, + 0x0, 0x2f, 0x90, 0x0, 0x48, 0x20, 0x0, 0xdf, + 0x60, 0x0, 0x0, 0x0, 0x5, 0xff, 0xa1, 0x0, + 0x0, 0x6, 0xf9, 0xbf, 0xe6, 0x0, 0x0, 0xfa, + 0x0, 0x6f, 0xfb, 0x0, 0x2f, 0x70, 0x0, 0x2c, + 0xfb, 0x0, 0xed, 0x10, 0x0, 0xd, 0xf2, 0x5, + 0xfe, 0x40, 0x0, 0x7f, 0x30, 0x4, 0xef, 0x91, + 0xb, 0xd0, 0x0, 0x1, 0xaf, 0xeb, 0xb2, 0x0, + 0x0, 0x0, 0x4e, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x1d, 0xf4, 0x0, 0x4b, 0x40, 0x0, 0x4f, 0x80, + 0x4, 0xfc, 0x0, 0x7, 0xf7, 0x0, 0xb, 0xfd, + 0x9a, 0xfe, 0x10, 0x0, 0x7, 0xdf, 0xe9, 0x10, + 0x0, + + /* U+00A8 "¨" */ + 0x1, 0x0, 0x1, 0x6, 0xf7, 0xc, 0xf1, 0x6f, + 0x70, 0xcf, 0x10, + + /* U+00A9 "©" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xbe, 0xfe, 0xa4, 0x0, 0x0, 0x0, + 0x2c, 0xe8, 0x44, 0x5a, 0xfa, 0x0, 0x0, 0x2e, + 0xa0, 0x0, 0x0, 0x2, 0xdc, 0x0, 0xc, 0xb0, + 0x7, 0xdf, 0xc5, 0x1, 0xe8, 0x5, 0xf1, 0x9, + 0xf6, 0x37, 0xf4, 0x4, 0xf1, 0xb9, 0x2, 0xf5, + 0x0, 0x7, 0x70, 0xd, 0x6e, 0x50, 0x6f, 0x0, + 0x0, 0x0, 0x0, 0x9a, 0xf3, 0x7, 0xd0, 0x0, + 0x0, 0x0, 0x8, 0xbe, 0x40, 0x5f, 0x0, 0x0, + 0x0, 0x0, 0x9a, 0xc8, 0x2, 0xf3, 0x0, 0x7, + 0xb0, 0xc, 0x77, 0xe0, 0xb, 0xd3, 0x5, 0xf6, + 0x2, 0xf2, 0xe, 0x80, 0x1b, 0xff, 0xf7, 0x0, + 0xca, 0x0, 0x4f, 0x80, 0x1, 0x20, 0x0, 0xbd, + 0x10, 0x0, 0x4f, 0xc5, 0x21, 0x27, 0xed, 0x20, + 0x0, 0x0, 0x19, 0xff, 0xff, 0xd7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x23, 0x10, 0x0, 0x0, 0x0, + + /* U+00AA "ª" */ + 0x5, 0xdf, 0xb6, 0xf1, 0x1f, 0x92, 0x9f, 0xd0, + 0x8f, 0x0, 0x1f, 0xa0, 0xad, 0x0, 0xd, 0x70, + 0xad, 0x0, 0xe, 0x70, 0x7f, 0x0, 0x1f, 0x90, + 0x1f, 0x92, 0xaf, 0xd0, 0x5, 0xef, 0xb6, 0xf1, + + /* U+00AB "«" */ + 0x0, 0x2, 0x30, 0x3, 0x20, 0x1, 0xe7, 0x4, + 0xf4, 0x0, 0xbe, 0x0, 0xdc, 0x0, 0x6f, 0x60, + 0x9f, 0x30, 0x1f, 0xd0, 0x3f, 0xa0, 0x7, 0xf8, + 0xa, 0xf4, 0x0, 0xd, 0xe0, 0x2f, 0xc0, 0x0, + 0x3f, 0x80, 0x6f, 0x50, 0x0, 0x8f, 0x10, 0xcd, + 0x0, 0x0, 0xd9, 0x2, 0xf7, + + /* U+00AC "¬" */ + 0xef, 0xff, 0xff, 0xff, 0xf9, 0x9b, 0xbb, 0xbb, + 0xbb, 0xf9, 0x0, 0x0, 0x0, 0x1, 0xf9, 0x0, + 0x0, 0x0, 0x1, 0xf9, 0x0, 0x0, 0x0, 0x1, + 0xf9, 0x0, 0x0, 0x0, 0x1, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x31, + + /* U+00AD "­" */ + 0x4d, 0xdd, 0xdd, 0x5, 0xff, 0xff, 0xf0, + + /* U+00AE "®" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xbe, 0xfe, 0xa4, 0x0, 0x0, 0x0, + 0x2c, 0xe8, 0x44, 0x5a, 0xfa, 0x0, 0x0, 0x2e, + 0xa0, 0x0, 0x0, 0x2, 0xdc, 0x0, 0xc, 0xb0, + 0x0, 0x0, 0x0, 0x1, 0xe8, 0x5, 0xf1, 0xd, + 0xff, 0xed, 0x60, 0x4, 0xf1, 0xb9, 0x0, 0xd8, + 0x22, 0x8f, 0x20, 0xd, 0x6e, 0x50, 0xd, 0x60, + 0x6, 0xf1, 0x0, 0x9a, 0xf3, 0x0, 0xdf, 0xff, + 0xd6, 0x0, 0x8, 0xbe, 0x40, 0xd, 0x83, 0xba, + 0x0, 0x0, 0x9a, 0xc8, 0x0, 0xd6, 0x1, 0xe7, + 0x0, 0xc, 0x77, 0xe0, 0xd, 0x60, 0x6, 0xf1, + 0x2, 0xf2, 0xe, 0x80, 0xa4, 0x0, 0xa, 0x60, + 0xca, 0x0, 0x4f, 0x80, 0x0, 0x0, 0x0, 0xbd, + 0x10, 0x0, 0x4f, 0xc5, 0x21, 0x27, 0xed, 0x20, + 0x0, 0x0, 0x19, 0xff, 0xff, 0xd7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x23, 0x10, 0x0, 0x0, 0x0, + + /* U+00B0 "°" */ + 0x6, 0xdd, 0x50, 0x4e, 0x44, 0xe3, 0x97, 0x0, + 0x79, 0xa6, 0x0, 0x6a, 0x5d, 0x11, 0xd5, 0x8, + 0xff, 0x80, 0x0, 0x0, 0x0, + + /* U+00B1 "±" */ + 0x0, 0x0, 0xc8, 0x0, 0x0, 0x0, 0x0, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0xfa, 0x0, 0x0, 0x9b, 0xbb, 0xfe, 0xbb, + 0xb6, 0xef, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xab, + 0xbb, 0xbb, 0xbb, 0xb6, 0xef, 0xff, 0xff, 0xff, + 0xf9, + + /* U+00B2 "²" */ + 0x6, 0xdf, 0xd5, 0x4, 0xf8, 0x3a, 0xf1, 0x25, + 0x0, 0x4f, 0x30, 0x0, 0x1c, 0xe0, 0x0, 0x2d, + 0xe3, 0x0, 0x3e, 0xd2, 0x0, 0x2e, 0xe4, 0x33, + 0xa, 0xff, 0xff, 0xf5, + + /* U+00B3 "³" */ + 0x7, 0xef, 0xc4, 0x4, 0xf5, 0x2c, 0xe0, 0x1, + 0x0, 0xcd, 0x0, 0x2, 0xff, 0x30, 0x0, 0x2, + 0xae, 0x12, 0x40, 0x4, 0xf4, 0x6f, 0x53, 0xbf, + 0x10, 0x8e, 0xfc, 0x40, + + /* U+00B5 "µ" */ + 0xaf, 0x10, 0x0, 0xf, 0xca, 0xf1, 0x0, 0x0, + 0xfc, 0xaf, 0x10, 0x0, 0xf, 0xca, 0xf1, 0x0, + 0x0, 0xfc, 0xaf, 0x10, 0x0, 0xf, 0xca, 0xf1, + 0x0, 0x0, 0xfc, 0xaf, 0x20, 0x0, 0xf, 0xca, + 0xf4, 0x0, 0x3, 0xfc, 0xaf, 0xc0, 0x0, 0xbf, + 0xca, 0xff, 0xea, 0xef, 0xec, 0xaf, 0x5c, 0xfd, + 0x4d, 0xca, 0xf1, 0x0, 0x0, 0x0, 0xaf, 0x10, + 0x0, 0x0, 0xa, 0xf1, 0x0, 0x0, 0x0, 0xaf, + 0x10, 0x0, 0x0, 0x0, + + /* U+00B6 "¶" */ + 0x0, 0x2a, 0xef, 0xff, 0xff, 0xfc, 0x2, 0xff, + 0xff, 0xec, 0xdf, 0xd9, 0xb, 0xff, 0xff, 0x80, + 0x4f, 0x50, 0xf, 0xff, 0xff, 0x80, 0x4f, 0x50, + 0xf, 0xff, 0xff, 0x80, 0x4f, 0x50, 0xe, 0xff, + 0xff, 0x80, 0x4f, 0x50, 0x7, 0xff, 0xff, 0x80, + 0x4f, 0x50, 0x0, 0x9f, 0xff, 0x80, 0x4f, 0x50, + 0x0, 0x2, 0x6f, 0x80, 0x4f, 0x50, 0x0, 0x0, + 0x1f, 0x80, 0x4f, 0x50, 0x0, 0x0, 0x1f, 0x80, + 0x4f, 0x50, 0x0, 0x0, 0x1f, 0x80, 0x4f, 0x50, + 0x0, 0x0, 0x1f, 0x80, 0x4f, 0x50, 0x0, 0x0, + 0x1f, 0x80, 0x4f, 0x50, 0x0, 0x0, 0x1f, 0x80, + 0x4f, 0x50, 0x0, 0x0, 0x1f, 0x80, 0x4f, 0x50, + 0x0, 0x0, 0x1f, 0x80, 0x4f, 0x50, 0x0, 0x0, + 0x1f, 0x80, 0x4f, 0x50, 0x0, 0x0, 0x1f, 0x80, + 0x4f, 0x50, + + /* U+00B7 "·" */ + 0x1, 0x3, 0xfc, 0x3f, 0xc0, + + /* U+00BB "»" */ + 0x13, 0x0, 0x22, 0x0, 0x3, 0xf5, 0x6, 0xf2, + 0x0, 0xa, 0xe1, 0xd, 0xc0, 0x0, 0x1f, 0xb0, + 0x4f, 0x80, 0x0, 0x8f, 0x50, 0xbf, 0x30, 0x2, + 0xfc, 0x6, 0xf9, 0x0, 0xaf, 0x30, 0xde, 0x10, + 0x3f, 0x80, 0x6f, 0x50, 0xc, 0xd0, 0xe, 0xa0, + 0x5, 0xf3, 0x8, 0xe1, 0x0, + + /* U+00BD "½" */ + 0x1, 0xca, 0x0, 0x0, 0x0, 0x5, 0xf3, 0x0, + 0x4d, 0xfa, 0x0, 0x0, 0x0, 0x1e, 0x70, 0x0, + 0xe8, 0xca, 0x0, 0x0, 0x0, 0xbc, 0x0, 0x0, + 0x0, 0xca, 0x0, 0x0, 0x6, 0xf2, 0x0, 0x0, + 0x0, 0xca, 0x0, 0x0, 0x2f, 0x60, 0x0, 0x0, + 0x0, 0xca, 0x0, 0x0, 0xcb, 0x0, 0x0, 0x0, + 0x0, 0xca, 0x0, 0x7, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x87, 0x0, 0x2f, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdb, 0x0, 0x7e, 0xfe, 0x70, + 0x0, 0x0, 0x8, 0xe1, 0x4, 0xf8, 0x3a, 0xf3, + 0x0, 0x0, 0x3f, 0x50, 0x1, 0x30, 0x5, 0xf2, + 0x0, 0x0, 0xda, 0x0, 0x0, 0x0, 0x4e, 0x90, + 0x0, 0x9, 0xe1, 0x0, 0x0, 0x8, 0xf7, 0x0, + 0x0, 0x4f, 0x40, 0x0, 0x0, 0xae, 0x40, 0x0, + 0x0, 0xe9, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf5, + 0x5, 0xa0, 0x0, 0x0, 0x2, 0x33, 0x33, 0x31, + + /* U+0384 "΄" */ + 0x9, 0xd6, 0x2f, 0xb0, 0x9e, 0x10, + + /* U+0386 "Ά" */ + 0x0, 0x6f, 0xb0, 0xbf, 0xb0, 0x0, 0x0, 0x0, + 0xd, 0xe1, 0x1f, 0xff, 0x10, 0x0, 0x0, 0x3, + 0xd3, 0x6, 0xf7, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xce, 0xe, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xa0, 0x9f, 0x40, 0x0, 0x0, 0x0, 0x8, + 0xf5, 0x4, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xef, + 0x0, 0xe, 0xf1, 0x0, 0x0, 0x0, 0x4f, 0xa0, + 0x0, 0x8f, 0x70, 0x0, 0x0, 0xa, 0xf4, 0x0, + 0x3, 0xfd, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x5f, 0xc9, 0x99, 0x99, + 0xbf, 0xa0, 0x0, 0xb, 0xf4, 0x0, 0x0, 0x1, + 0xff, 0x0, 0x1, 0xfe, 0x0, 0x0, 0x0, 0xb, + 0xf6, 0x0, 0x7f, 0x80, 0x0, 0x0, 0x0, 0x5f, + 0xc0, 0xd, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xef, + 0x30, + + /* U+0388 "Έ" */ + 0xc, 0xf5, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0x4f, 0x90, 0x1f, 0xfc, 0xcc, 0xcc, 0xcc, 0xc3, + 0x9b, 0x0, 0x1f, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xfc, 0xcc, 0xcc, 0xcc, 0x80, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x1f, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xfc, 0xcc, 0xcc, 0xcc, 0xc7, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xf9, + + /* U+0389 "Ή" */ + 0xc, 0xf5, 0x7f, 0x60, 0x0, 0x0, 0x2, 0xfc, + 0x4f, 0x90, 0x7f, 0x60, 0x0, 0x0, 0x2, 0xfc, + 0x8b, 0x0, 0x7f, 0x60, 0x0, 0x0, 0x2, 0xfc, + 0x0, 0x0, 0x7f, 0x60, 0x0, 0x0, 0x2, 0xfc, + 0x0, 0x0, 0x7f, 0x60, 0x0, 0x0, 0x2, 0xfc, + 0x0, 0x0, 0x7f, 0x60, 0x0, 0x0, 0x2, 0xfc, + 0x0, 0x0, 0x7f, 0xdc, 0xcc, 0xcc, 0xcc, 0xfc, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x7f, 0x60, 0x0, 0x0, 0x2, 0xfc, + 0x0, 0x0, 0x7f, 0x60, 0x0, 0x0, 0x2, 0xfc, + 0x0, 0x0, 0x7f, 0x60, 0x0, 0x0, 0x2, 0xfc, + 0x0, 0x0, 0x7f, 0x60, 0x0, 0x0, 0x2, 0xfc, + 0x0, 0x0, 0x7f, 0x60, 0x0, 0x0, 0x2, 0xfc, + 0x0, 0x0, 0x7f, 0x60, 0x0, 0x0, 0x2, 0xfc, + 0x0, 0x0, 0x7f, 0x60, 0x0, 0x0, 0x2, 0xfc, + + /* U+038A "Ί" */ + 0xc, 0xf5, 0x7f, 0x64, 0xf9, 0x7, 0xf6, 0x8b, + 0x0, 0x7f, 0x60, 0x0, 0x7, 0xf6, 0x0, 0x0, + 0x7f, 0x60, 0x0, 0x7, 0xf6, 0x0, 0x0, 0x7f, + 0x60, 0x0, 0x7, 0xf6, 0x0, 0x0, 0x7f, 0x60, + 0x0, 0x7, 0xf6, 0x0, 0x0, 0x7f, 0x60, 0x0, + 0x7, 0xf6, 0x0, 0x0, 0x7f, 0x60, 0x0, 0x7, + 0xf6, 0x0, 0x0, 0x7f, 0x60, + + /* U+038C "Ό" */ + 0xc, 0xf5, 0x3, 0xae, 0xfe, 0xc6, 0x0, 0x0, + 0x4f, 0x90, 0x9f, 0xfd, 0xbc, 0xff, 0xd2, 0x0, + 0x9b, 0x8, 0xfd, 0x30, 0x0, 0x19, 0xfe, 0x10, + 0x0, 0x3f, 0xe1, 0x0, 0x0, 0x0, 0x9f, 0x90, + 0x0, 0xaf, 0x60, 0x0, 0x0, 0x0, 0xf, 0xf1, + 0x0, 0xef, 0x10, 0x0, 0x0, 0x0, 0xa, 0xf5, + 0x0, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x7, 0xf7, + 0x1, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x6, 0xf8, + 0x0, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x7, 0xf7, + 0x0, 0xef, 0x0, 0x0, 0x0, 0x0, 0xa, 0xf5, + 0x0, 0x9f, 0x60, 0x0, 0x0, 0x0, 0xf, 0xf1, + 0x0, 0x3f, 0xe1, 0x0, 0x0, 0x0, 0x9f, 0x90, + 0x0, 0x8, 0xfd, 0x30, 0x0, 0x9, 0xfe, 0x10, + 0x0, 0x0, 0x8f, 0xfd, 0xbb, 0xff, 0xd2, 0x0, + 0x0, 0x0, 0x3, 0xae, 0xfe, 0xc6, 0x0, 0x0, + + /* U+038E "Ύ" */ + 0xc, 0xf5, 0x1e, 0xf5, 0x0, 0x0, 0x0, 0xb, + 0xf8, 0x4f, 0x90, 0x5, 0xfe, 0x0, 0x0, 0x0, + 0x5f, 0xd0, 0x9b, 0x0, 0x0, 0xaf, 0x90, 0x0, + 0x0, 0xef, 0x30, 0x0, 0x0, 0x0, 0x1f, 0xf3, + 0x0, 0x9, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xfd, 0x0, 0x3f, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0x60, 0xcf, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xe7, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0x20, 0x0, 0x0, + + /* U+038F "Ώ" */ + 0xc, 0xf5, 0x3, 0xad, 0xfe, 0xb5, 0x0, 0x0, + 0x4f, 0x90, 0x7f, 0xfd, 0xbc, 0xff, 0xa0, 0x0, + 0x9b, 0x6, 0xfe, 0x40, 0x0, 0x2d, 0xf8, 0x0, + 0x0, 0x1f, 0xf4, 0x0, 0x0, 0x1, 0xff, 0x20, + 0x0, 0x6f, 0xb0, 0x0, 0x0, 0x0, 0x8f, 0x80, + 0x0, 0xaf, 0x60, 0x0, 0x0, 0x0, 0x3f, 0xc0, + 0x0, 0xbf, 0x30, 0x0, 0x0, 0x0, 0xf, 0xe0, + 0x0, 0xbf, 0x30, 0x0, 0x0, 0x0, 0xf, 0xe0, + 0x0, 0xaf, 0x40, 0x0, 0x0, 0x0, 0x1f, 0xc0, + 0x0, 0x5f, 0x70, 0x0, 0x0, 0x0, 0x4f, 0x80, + 0x0, 0xe, 0xd0, 0x0, 0x0, 0x0, 0xaf, 0x20, + 0x0, 0x6, 0xf7, 0x0, 0x0, 0x4, 0xf8, 0x0, + 0x0, 0x0, 0x8f, 0x60, 0x0, 0x4e, 0xa0, 0x0, + 0x0, 0xbc, 0xcf, 0xf8, 0x5, 0xff, 0xcc, 0xc1, + 0x0, 0xff, 0xff, 0xfa, 0x7, 0xff, 0xff, 0xf1, + + /* U+0390 "ΐ" */ + 0x5f, 0x51, 0xf9, 0xec, 0x4f, 0x5a, 0x90, 0xdb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xf1, 0x0, 0x0, 0xa, 0xf1, 0x0, + 0x0, 0xa, 0xf1, 0x0, 0x0, 0xa, 0xf1, 0x0, + 0x0, 0xa, 0xf1, 0x0, 0x0, 0xa, 0xf1, 0x0, + 0x0, 0xa, 0xf1, 0x0, 0x0, 0xa, 0xf1, 0x0, + 0x0, 0xa, 0xf1, 0x0, 0x0, 0xa, 0xf1, 0x0, + 0x0, 0xa, 0xf1, 0x0, + + /* U+0391 "Α" */ + 0x0, 0x0, 0x0, 0xbf, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xf7, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xe, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xa0, 0x9f, 0x40, 0x0, 0x0, 0x0, 0x8, + 0xf5, 0x4, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xef, + 0x0, 0xe, 0xf1, 0x0, 0x0, 0x0, 0x4f, 0xa0, + 0x0, 0x9f, 0x70, 0x0, 0x0, 0xa, 0xf4, 0x0, + 0x3, 0xfd, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x5f, 0xc9, 0x99, 0x99, + 0xbf, 0xa0, 0x0, 0xb, 0xf4, 0x0, 0x0, 0x1, + 0xff, 0x0, 0x1, 0xfe, 0x0, 0x0, 0x0, 0xb, + 0xf6, 0x0, 0x7f, 0x80, 0x0, 0x0, 0x0, 0x5f, + 0xc0, 0xd, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xef, + 0x30, + + /* U+0392 "Β" */ + 0x8f, 0xff, 0xff, 0xfd, 0x70, 0x0, 0x8f, 0xdc, + 0xcc, 0xdf, 0xfc, 0x0, 0x8f, 0x60, 0x0, 0x1, + 0xcf, 0x50, 0x8f, 0x60, 0x0, 0x0, 0x5f, 0x80, + 0x8f, 0x60, 0x0, 0x0, 0x5f, 0x70, 0x8f, 0x60, + 0x0, 0x1, 0xcf, 0x20, 0x8f, 0xdc, 0xcc, 0xdf, + 0xe4, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xf9, 0x0, + 0x8f, 0x60, 0x0, 0x14, 0xbf, 0xa0, 0x8f, 0x60, + 0x0, 0x0, 0xe, 0xf1, 0x8f, 0x60, 0x0, 0x0, + 0xb, 0xf3, 0x8f, 0x60, 0x0, 0x0, 0xd, 0xf2, + 0x8f, 0x60, 0x0, 0x0, 0x7f, 0xe0, 0x8f, 0xdc, + 0xcc, 0xce, 0xff, 0x40, 0x8f, 0xff, 0xff, 0xfe, + 0xa3, 0x0, + + /* U+0393 "Γ" */ + 0x6f, 0xff, 0xff, 0xff, 0xf8, 0x6f, 0xec, 0xcc, + 0xcc, 0xc6, 0x6f, 0x80, 0x0, 0x0, 0x0, 0x6f, + 0x80, 0x0, 0x0, 0x0, 0x6f, 0x80, 0x0, 0x0, + 0x0, 0x6f, 0x80, 0x0, 0x0, 0x0, 0x6f, 0x80, + 0x0, 0x0, 0x0, 0x6f, 0x80, 0x0, 0x0, 0x0, + 0x6f, 0x80, 0x0, 0x0, 0x0, 0x6f, 0x80, 0x0, + 0x0, 0x0, 0x6f, 0x80, 0x0, 0x0, 0x0, 0x6f, + 0x80, 0x0, 0x0, 0x0, 0x6f, 0x80, 0x0, 0x0, + 0x0, 0x6f, 0x80, 0x0, 0x0, 0x0, 0x6f, 0x80, + 0x0, 0x0, 0x0, + + /* U+0394 "Δ" */ + 0x0, 0x0, 0x0, 0xbf, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xf7, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xce, 0xe, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xa0, 0x9f, 0x40, 0x0, 0x0, 0x0, 0x8, + 0xf5, 0x3, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xee, + 0x0, 0xd, 0xf1, 0x0, 0x0, 0x0, 0x4f, 0x90, + 0x0, 0x8f, 0x70, 0x0, 0x0, 0xa, 0xf4, 0x0, + 0x2, 0xfd, 0x0, 0x0, 0x0, 0xfe, 0x0, 0x0, + 0xc, 0xf3, 0x0, 0x0, 0x5f, 0x90, 0x0, 0x0, + 0x6f, 0x90, 0x0, 0xb, 0xf3, 0x0, 0x0, 0x1, + 0xff, 0x0, 0x1, 0xfd, 0x0, 0x0, 0x0, 0xb, + 0xf6, 0x0, 0x7f, 0xec, 0xcc, 0xcc, 0xcc, 0xdf, + 0xc0, 0xd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x20, + + /* U+0395 "Ε" */ + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x6f, 0xdc, + 0xcc, 0xcc, 0xcc, 0xb0, 0x6f, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0x70, 0x0, 0x0, 0x0, 0x0, 0x6f, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xdc, 0xcc, 0xcc, + 0xcc, 0x40, 0x6f, 0xff, 0xff, 0xff, 0xff, 0x60, + 0x6f, 0x70, 0x0, 0x0, 0x0, 0x0, 0x6f, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0x70, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xdc, + 0xcc, 0xcc, 0xcc, 0xc3, 0x6f, 0xff, 0xff, 0xff, + 0xff, 0xf4, + + /* U+0396 "Ζ" */ + 0xd, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x9, 0xcc, + 0xcc, 0xcc, 0xcf, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xd0, 0x0, 0x0, 0x0, 0x4, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x1e, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0x80, 0x0, 0x0, 0x0, 0x8, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xe1, 0x0, 0x0, + 0x0, 0x2, 0xff, 0x40, 0x0, 0x0, 0x0, 0xc, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xb0, 0x0, + 0x0, 0x0, 0x5, 0xfd, 0x10, 0x0, 0x0, 0x0, + 0x2f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xec, + 0xcc, 0xcc, 0xcc, 0xc8, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xfb, + + /* U+0397 "Η" */ + 0x6f, 0x80, 0x0, 0x0, 0x1, 0xfd, 0x6f, 0x80, + 0x0, 0x0, 0x1, 0xfd, 0x6f, 0x80, 0x0, 0x0, + 0x1, 0xfd, 0x6f, 0x80, 0x0, 0x0, 0x1, 0xfd, + 0x6f, 0x80, 0x0, 0x0, 0x1, 0xfd, 0x6f, 0x80, + 0x0, 0x0, 0x1, 0xfd, 0x6f, 0xec, 0xcc, 0xcc, + 0xcc, 0xfd, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x6f, 0x80, 0x0, 0x0, 0x1, 0xfd, 0x6f, 0x80, + 0x0, 0x0, 0x1, 0xfd, 0x6f, 0x80, 0x0, 0x0, + 0x1, 0xfd, 0x6f, 0x80, 0x0, 0x0, 0x1, 0xfd, + 0x6f, 0x80, 0x0, 0x0, 0x1, 0xfd, 0x6f, 0x80, + 0x0, 0x0, 0x1, 0xfd, 0x6f, 0x80, 0x0, 0x0, + 0x1, 0xfd, + + /* U+0398 "Θ" */ + 0x0, 0x0, 0x39, 0xdf, 0xec, 0x70, 0x0, 0x0, + 0x0, 0x8f, 0xfd, 0xbc, 0xff, 0xe2, 0x0, 0x0, + 0x7f, 0xe4, 0x0, 0x0, 0x8f, 0xe1, 0x0, 0x2f, + 0xe1, 0x0, 0x0, 0x0, 0x8f, 0xa0, 0x9, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xef, 0x20, 0xdf, 0x20, + 0x0, 0x0, 0x0, 0x9, 0xf6, 0xf, 0xf0, 0xc, + 0xcc, 0xcc, 0x70, 0x6f, 0x80, 0xfe, 0x0, 0xff, + 0xff, 0xf9, 0x5, 0xf9, 0xf, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0x80, 0xdf, 0x10, 0x0, 0x0, + 0x0, 0x9, 0xf6, 0x8, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0xef, 0x20, 0x2f, 0xe1, 0x0, 0x0, 0x0, + 0x7f, 0xb0, 0x0, 0x7f, 0xd3, 0x0, 0x0, 0x8f, + 0xe1, 0x0, 0x0, 0x7f, 0xfd, 0xbb, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x3a, 0xef, 0xfc, 0x70, 0x0, + 0x0, + + /* U+0399 "Ι" */ + 0x2f, 0xb2, 0xfb, 0x2f, 0xb2, 0xfb, 0x2f, 0xb2, + 0xfb, 0x2f, 0xb2, 0xfb, 0x2f, 0xb2, 0xfb, 0x2f, + 0xb2, 0xfb, 0x2f, 0xb2, 0xfb, 0x2f, 0xb0, + + /* U+039A "Κ" */ + 0x8f, 0x60, 0x0, 0x0, 0x1e, 0xf8, 0x8, 0xf6, + 0x0, 0x0, 0x1d, 0xf9, 0x0, 0x8f, 0x60, 0x0, + 0x1d, 0xf9, 0x0, 0x8, 0xf6, 0x0, 0xc, 0xf9, + 0x0, 0x0, 0x8f, 0x60, 0xc, 0xf9, 0x0, 0x0, + 0x8, 0xf6, 0xb, 0xf9, 0x0, 0x0, 0x0, 0x8f, + 0x6b, 0xff, 0x50, 0x0, 0x0, 0x8, 0xfe, 0xfb, + 0xfe, 0x10, 0x0, 0x0, 0x8f, 0xfa, 0x8, 0xfb, + 0x0, 0x0, 0x8, 0xfa, 0x0, 0xd, 0xf7, 0x0, + 0x0, 0x8f, 0x60, 0x0, 0x3f, 0xf2, 0x0, 0x8, + 0xf6, 0x0, 0x0, 0x8f, 0xd0, 0x0, 0x8f, 0x60, + 0x0, 0x0, 0xdf, 0x80, 0x8, 0xf6, 0x0, 0x0, + 0x3, 0xff, 0x40, 0x8f, 0x60, 0x0, 0x0, 0x8, + 0xfe, 0x10, + + /* U+039B "Λ" */ + 0x0, 0x0, 0x7, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0x7f, 0x90, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0x1c, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xfc, 0x7, + 0xf5, 0x0, 0x0, 0x0, 0x5, 0xf6, 0x1, 0xfb, + 0x0, 0x0, 0x0, 0xb, 0xf1, 0x0, 0xcf, 0x10, + 0x0, 0x0, 0x1f, 0xb0, 0x0, 0x6f, 0x60, 0x0, + 0x0, 0x7f, 0x50, 0x0, 0x1f, 0xc0, 0x0, 0x0, + 0xdf, 0x0, 0x0, 0xb, 0xf2, 0x0, 0x3, 0xfa, + 0x0, 0x0, 0x6, 0xf8, 0x0, 0x9, 0xf4, 0x0, + 0x0, 0x1, 0xfe, 0x0, 0xe, 0xe0, 0x0, 0x0, + 0x0, 0xbf, 0x40, 0x5f, 0x90, 0x0, 0x0, 0x0, + 0x6f, 0xa0, 0xbf, 0x30, 0x0, 0x0, 0x0, 0xf, + 0xf0, + + /* U+039C "Μ" */ + 0x8f, 0xf8, 0x0, 0x0, 0x0, 0x8, 0xff, 0x28, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0xdf, 0xf2, 0x8f, + 0xef, 0x20, 0x0, 0x0, 0x3f, 0xff, 0x28, 0xf9, + 0xf7, 0x0, 0x0, 0x8, 0xfb, 0xf2, 0x8f, 0x5e, + 0xc0, 0x0, 0x0, 0xda, 0xaf, 0x28, 0xf5, 0x9f, + 0x10, 0x0, 0x3f, 0x5a, 0xf2, 0x8f, 0x54, 0xf6, + 0x0, 0x8, 0xf0, 0xaf, 0x28, 0xf5, 0xf, 0xc0, + 0x0, 0xda, 0xa, 0xf2, 0x8f, 0x50, 0xaf, 0x10, + 0x2f, 0x50, 0xaf, 0x28, 0xf5, 0x5, 0xf6, 0x8, + 0xf0, 0xa, 0xf2, 0x8f, 0x50, 0xf, 0xb0, 0xda, + 0x0, 0xaf, 0x28, 0xf5, 0x0, 0xaf, 0x3f, 0x50, + 0xa, 0xf2, 0x8f, 0x50, 0x5, 0xfc, 0xf0, 0x0, + 0xaf, 0x28, 0xf5, 0x0, 0xf, 0xfa, 0x0, 0xa, + 0xf2, 0x8f, 0x50, 0x0, 0xbf, 0x50, 0x0, 0xaf, + 0x20, + + /* U+039D "Ν" */ + 0x6f, 0xd0, 0x0, 0x0, 0x0, 0xfd, 0x6f, 0xf7, + 0x0, 0x0, 0x0, 0xfd, 0x6f, 0xff, 0x20, 0x0, + 0x0, 0xfd, 0x6f, 0xcf, 0xc0, 0x0, 0x0, 0xfd, + 0x6f, 0x6c, 0xf6, 0x0, 0x0, 0xfd, 0x6f, 0x62, + 0xff, 0x10, 0x0, 0xfd, 0x6f, 0x60, 0x8f, 0xa0, + 0x0, 0xfd, 0x6f, 0x60, 0xd, 0xf5, 0x0, 0xfd, + 0x6f, 0x60, 0x3, 0xfe, 0x0, 0xfd, 0x6f, 0x60, + 0x0, 0x9f, 0x90, 0xfd, 0x6f, 0x60, 0x0, 0xe, + 0xf3, 0xfd, 0x6f, 0x60, 0x0, 0x5, 0xfd, 0xfd, + 0x6f, 0x60, 0x0, 0x0, 0xaf, 0xfd, 0x6f, 0x60, + 0x0, 0x0, 0x1f, 0xfd, 0x6f, 0x60, 0x0, 0x0, + 0x6, 0xfd, + + /* U+039E "Ξ" */ + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xa8, 0xcc, 0xcc, + 0xcc, 0xcc, 0xc8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xff, 0xc0, 0x9, 0xcc, 0xcc, 0xcc, + 0xc9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xcc, 0xcc, 0xcc, 0xcc, 0xcb, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf0, + + /* U+039F "Ο" */ + 0x0, 0x0, 0x39, 0xdf, 0xec, 0x70, 0x0, 0x0, + 0x0, 0x8f, 0xfd, 0xbc, 0xff, 0xe2, 0x0, 0x0, + 0x7f, 0xe4, 0x0, 0x0, 0x8f, 0xe1, 0x0, 0x2f, + 0xe1, 0x0, 0x0, 0x0, 0x8f, 0xa0, 0x9, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xef, 0x20, 0xdf, 0x20, + 0x0, 0x0, 0x0, 0x9, 0xf6, 0xf, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0x80, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xf9, 0xf, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0x80, 0xdf, 0x10, 0x0, 0x0, + 0x0, 0x9, 0xf6, 0x8, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0xef, 0x20, 0x2f, 0xe1, 0x0, 0x0, 0x0, + 0x7f, 0xb0, 0x0, 0x7f, 0xd3, 0x0, 0x0, 0x8f, + 0xe1, 0x0, 0x0, 0x7f, 0xfd, 0xbb, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x3a, 0xef, 0xfc, 0x70, 0x0, + 0x0, + + /* U+03A0 "Π" */ + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x6f, 0xec, + 0xcc, 0xcc, 0xcc, 0xfd, 0x6f, 0x80, 0x0, 0x0, + 0x1, 0xfd, 0x6f, 0x80, 0x0, 0x0, 0x1, 0xfd, + 0x6f, 0x80, 0x0, 0x0, 0x1, 0xfd, 0x6f, 0x80, + 0x0, 0x0, 0x1, 0xfd, 0x6f, 0x80, 0x0, 0x0, + 0x1, 0xfd, 0x6f, 0x80, 0x0, 0x0, 0x1, 0xfd, + 0x6f, 0x80, 0x0, 0x0, 0x1, 0xfd, 0x6f, 0x80, + 0x0, 0x0, 0x1, 0xfd, 0x6f, 0x80, 0x0, 0x0, + 0x1, 0xfd, 0x6f, 0x80, 0x0, 0x0, 0x1, 0xfd, + 0x6f, 0x80, 0x0, 0x0, 0x1, 0xfd, 0x6f, 0x80, + 0x0, 0x0, 0x1, 0xfd, 0x6f, 0x80, 0x0, 0x0, + 0x1, 0xfd, + + /* U+03A1 "Ρ" */ + 0x7f, 0xff, 0xff, 0xfe, 0xb5, 0x0, 0x7f, 0xdc, + 0xcc, 0xcd, 0xff, 0x70, 0x7f, 0x70, 0x0, 0x0, + 0x4f, 0xf1, 0x7f, 0x70, 0x0, 0x0, 0xa, 0xf5, + 0x7f, 0x70, 0x0, 0x0, 0x8, 0xf7, 0x7f, 0x70, + 0x0, 0x0, 0xb, 0xf5, 0x7f, 0x70, 0x0, 0x0, + 0x6f, 0xf1, 0x7f, 0xdc, 0xcc, 0xce, 0xff, 0x60, + 0x7f, 0xff, 0xff, 0xfe, 0xa4, 0x0, 0x7f, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0x70, 0x0, 0x0, 0x0, 0x0, 0x7f, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0x70, 0x0, 0x0, + 0x0, 0x0, + + /* U+03A3 "Σ" */ + 0x8f, 0xff, 0xff, 0xff, 0xff, 0x38, 0xfe, 0xcc, + 0xcc, 0xcc, 0xc2, 0x2e, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xd1, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xb0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0x20, 0x0, 0x0, 0x1, 0xdf, 0x50, + 0x0, 0x0, 0x0, 0xbf, 0x80, 0x0, 0x0, 0x0, + 0x8f, 0xb0, 0x0, 0x0, 0x0, 0x5f, 0xd0, 0x0, + 0x0, 0x0, 0x3f, 0xf2, 0x0, 0x0, 0x0, 0x8, + 0xfe, 0xcc, 0xcc, 0xcc, 0xc6, 0x8f, 0xff, 0xff, + 0xff, 0xff, 0x90, + + /* U+03A4 "Τ" */ + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x6c, 0xcc, + 0xcf, 0xfc, 0xcc, 0xc9, 0x0, 0x0, 0xd, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xf0, + 0x0, 0x0, + + /* U+03A5 "Υ" */ + 0x9f, 0xa0, 0x0, 0x0, 0x0, 0x5f, 0xd0, 0x1e, + 0xf4, 0x0, 0x0, 0x0, 0xef, 0x30, 0x5, 0xfe, + 0x0, 0x0, 0x9, 0xf8, 0x0, 0x0, 0xbf, 0x80, + 0x0, 0x3f, 0xd0, 0x0, 0x0, 0x1f, 0xf2, 0x0, + 0xdf, 0x30, 0x0, 0x0, 0x6, 0xfb, 0x7, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0x6f, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xf7, 0x0, 0x0, + 0x0, + + /* U+03A6 "Φ" */ + 0x0, 0x0, 0x0, 0xf, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0x8d, 0xff, 0xff, 0xd9, 0x20, 0x0, + 0x0, 0x5f, 0xfd, 0xaf, 0xfa, 0xdf, 0xf5, 0x0, + 0x2, 0xff, 0x40, 0xf, 0xe0, 0x5, 0xff, 0x30, + 0xa, 0xf5, 0x0, 0xf, 0xe0, 0x0, 0x6f, 0xb0, + 0xf, 0xf0, 0x0, 0xf, 0xe0, 0x0, 0xf, 0xf0, + 0x2f, 0xd0, 0x0, 0xf, 0xe0, 0x0, 0xd, 0xf1, + 0x1f, 0xd0, 0x0, 0xf, 0xe0, 0x0, 0xd, 0xf0, + 0xe, 0xf1, 0x0, 0xf, 0xe0, 0x0, 0x1f, 0xe0, + 0x9, 0xfa, 0x0, 0xf, 0xe0, 0x0, 0xaf, 0x80, + 0x1, 0xdf, 0xb3, 0xf, 0xe0, 0x3b, 0xfd, 0x0, + 0x0, 0x1b, 0xff, 0xff, 0xff, 0xff, 0xa1, 0x0, + 0x0, 0x0, 0x37, 0x9f, 0xf9, 0x72, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xb0, 0x0, 0x0, 0x0, + + /* U+03A7 "Χ" */ + 0xd, 0xf5, 0x0, 0x0, 0x0, 0x9f, 0x70, 0x3, + 0xfe, 0x10, 0x0, 0x5, 0xfc, 0x0, 0x0, 0x8f, + 0xa0, 0x0, 0x1e, 0xe1, 0x0, 0x0, 0xd, 0xf5, + 0x0, 0xcf, 0x50, 0x0, 0x0, 0x3, 0xfe, 0x17, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xbf, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xef, 0xc0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0x2c, 0xf7, 0x0, 0x0, 0x0, 0xb, + 0xf7, 0x2, 0xff, 0x20, 0x0, 0x0, 0x6f, 0xc0, + 0x0, 0x7f, 0xc0, 0x0, 0x2, 0xff, 0x20, 0x0, + 0xc, 0xf8, 0x0, 0xd, 0xf6, 0x0, 0x0, 0x2, + 0xff, 0x30, 0x8f, 0xb0, 0x0, 0x0, 0x0, 0x7f, + 0xd0, + + /* U+03A8 "Ψ" */ + 0xcf, 0x20, 0x0, 0x9f, 0x40, 0x0, 0x7f, 0x7c, + 0xf2, 0x0, 0x9, 0xf4, 0x0, 0x7, 0xf7, 0xcf, + 0x20, 0x0, 0x9f, 0x40, 0x0, 0x7f, 0x7c, 0xf2, + 0x0, 0x9, 0xf4, 0x0, 0x7, 0xf7, 0xcf, 0x20, + 0x0, 0x9f, 0x40, 0x0, 0x7f, 0x7b, 0xf3, 0x0, + 0x9, 0xf4, 0x0, 0x8, 0xf6, 0x8f, 0x70, 0x0, + 0x9f, 0x40, 0x0, 0xcf, 0x33, 0xfe, 0x10, 0x9, + 0xf4, 0x0, 0x4f, 0xe0, 0xa, 0xfd, 0x51, 0x9f, + 0x52, 0x7f, 0xf6, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x3, 0x7a, 0xdf, 0xc9, + 0x61, 0x0, 0x0, 0x0, 0x0, 0x9, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0x40, 0x0, 0x0, + 0x0, + + /* U+03A9 "Ω" */ + 0x0, 0x0, 0x4a, 0xdf, 0xeb, 0x40, 0x0, 0x0, + 0x0, 0x9f, 0xfd, 0xbd, 0xff, 0x90, 0x0, 0x0, + 0x8f, 0xe3, 0x0, 0x3, 0xef, 0x70, 0x0, 0x2f, + 0xf2, 0x0, 0x0, 0x3, 0xff, 0x10, 0x7, 0xf9, + 0x0, 0x0, 0x0, 0x9, 0xf7, 0x0, 0xbf, 0x40, + 0x0, 0x0, 0x0, 0x4f, 0xb0, 0xd, 0xf1, 0x0, + 0x0, 0x0, 0x2, 0xfc, 0x0, 0xdf, 0x10, 0x0, + 0x0, 0x0, 0x1f, 0xc0, 0xb, 0xf3, 0x0, 0x0, + 0x0, 0x3, 0xfb, 0x0, 0x7f, 0x50, 0x0, 0x0, + 0x0, 0x6f, 0x60, 0x1, 0xfb, 0x0, 0x0, 0x0, + 0xb, 0xf1, 0x0, 0x7, 0xf5, 0x0, 0x0, 0x5, + 0xf6, 0x0, 0x0, 0xa, 0xf5, 0x0, 0x5, 0xf9, + 0x0, 0x0, 0xcc, 0xcf, 0xf6, 0x7, 0xff, 0xcc, + 0xc0, 0xf, 0xff, 0xff, 0x80, 0x8f, 0xff, 0xff, + 0x0, + + /* U+03AA "Ϊ" */ + 0xf, 0xd0, 0x5f, 0x70, 0xfd, 0x5, 0xf7, 0x1, + 0x10, 0x1, 0x0, 0x3, 0xfb, 0x0, 0x0, 0x3f, + 0xb0, 0x0, 0x3, 0xfb, 0x0, 0x0, 0x3f, 0xb0, + 0x0, 0x3, 0xfb, 0x0, 0x0, 0x3f, 0xb0, 0x0, + 0x3, 0xfb, 0x0, 0x0, 0x3f, 0xb0, 0x0, 0x3, + 0xfb, 0x0, 0x0, 0x3f, 0xb0, 0x0, 0x3, 0xfb, + 0x0, 0x0, 0x3f, 0xb0, 0x0, 0x3, 0xfb, 0x0, + 0x0, 0x3f, 0xb0, 0x0, 0x3, 0xfb, 0x0, + + /* U+03AB "Ϋ" */ + 0x0, 0x1, 0xfb, 0x7, 0xf5, 0x0, 0x0, 0x0, + 0x1, 0xfb, 0x7, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x10, 0x0, 0x10, 0x0, 0x0, 0x9f, 0xa0, 0x0, + 0x0, 0x0, 0x5f, 0xd0, 0x1e, 0xf4, 0x0, 0x0, + 0x0, 0xef, 0x30, 0x5, 0xfe, 0x0, 0x0, 0x9, + 0xf8, 0x0, 0x0, 0xbf, 0x80, 0x0, 0x3f, 0xd0, + 0x0, 0x0, 0x1f, 0xf2, 0x0, 0xdf, 0x30, 0x0, + 0x0, 0x6, 0xfb, 0x7, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0x6f, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xf7, 0x0, 0x0, 0x0, + + /* U+03AC "ά" */ + 0x0, 0x0, 0x6, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0xde, 0x10, 0x0, 0x0, 0x0, 0x3d, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2b, + 0xff, 0xb3, 0x2f, 0xa0, 0x2f, 0xf7, 0x49, 0xfa, + 0xf6, 0xb, 0xf5, 0x0, 0x9, 0xff, 0x21, 0xfe, + 0x0, 0x0, 0x2f, 0xf0, 0x3f, 0xb0, 0x0, 0x0, + 0xfb, 0x4, 0xfa, 0x0, 0x0, 0xe, 0x90, 0x3f, + 0xb0, 0x0, 0x0, 0xfb, 0x0, 0xfe, 0x0, 0x0, + 0x3f, 0xe0, 0xb, 0xf5, 0x0, 0xb, 0xff, 0x20, + 0x2e, 0xe6, 0x4a, 0xf9, 0xf5, 0x0, 0x2b, 0xff, + 0xc3, 0x1f, 0xa0, + + /* U+03AD "έ" */ + 0x0, 0x0, 0x7f, 0xa0, 0x0, 0x0, 0xe, 0xd0, + 0x0, 0x0, 0x5, 0xd2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5d, 0xfe, 0xa2, 0x0, 0x4f, + 0xd9, 0xcf, 0xc0, 0xa, 0xf1, 0x0, 0x31, 0x0, + 0xaf, 0x20, 0x0, 0x0, 0x3, 0xfe, 0x96, 0x0, + 0x0, 0x1c, 0xff, 0xb0, 0x0, 0xb, 0xf8, 0x10, + 0x0, 0x0, 0xfd, 0x0, 0x0, 0x0, 0xe, 0xe1, + 0x0, 0x38, 0x0, 0x8f, 0xd8, 0xaf, 0xf2, 0x0, + 0x7d, 0xfe, 0xa2, 0x0, + + /* U+03AE "ή" */ + 0x0, 0x0, 0x8f, 0xa0, 0x0, 0x0, 0xe, 0xd0, + 0x0, 0x0, 0x5, 0xd2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0x2a, 0xef, 0xc4, 0xa, 0xfe, + 0xb6, 0x7e, 0xf3, 0xaf, 0xa0, 0x0, 0x4f, 0x9a, + 0xf4, 0x0, 0x0, 0xfb, 0xaf, 0x20, 0x0, 0xf, + 0xca, 0xf1, 0x0, 0x0, 0xfc, 0xaf, 0x10, 0x0, + 0xf, 0xca, 0xf1, 0x0, 0x0, 0xfc, 0xaf, 0x10, + 0x0, 0xf, 0xca, 0xf1, 0x0, 0x0, 0xfc, 0xaf, + 0x10, 0x0, 0xf, 0xc0, 0x0, 0x0, 0x0, 0xfc, + 0x0, 0x0, 0x0, 0xf, 0xc0, 0x0, 0x0, 0x0, + 0xfc, 0x0, 0x0, 0x0, 0xf, 0xc0, + + /* U+03AF "ί" */ + 0xd, 0xf4, 0x5f, 0x80, 0xaa, 0x0, 0x0, 0x0, + 0xaf, 0x10, 0xaf, 0x10, 0xaf, 0x10, 0xaf, 0x10, + 0xaf, 0x10, 0xaf, 0x10, 0xaf, 0x10, 0xaf, 0x10, + 0xaf, 0x10, 0xaf, 0x10, 0xaf, 0x10, + + /* U+03B0 "ΰ" */ + 0x1f, 0xa0, 0xcc, 0xbf, 0x0, 0xf9, 0x6c, 0x9, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0x10, 0x0, 0x2f, 0xaa, 0xf1, + 0x0, 0x2, 0xfa, 0xaf, 0x10, 0x0, 0x2f, 0xaa, + 0xf1, 0x0, 0x2, 0xfa, 0xaf, 0x10, 0x0, 0x2f, + 0xaa, 0xf1, 0x0, 0x2, 0xfa, 0xaf, 0x10, 0x0, + 0x2f, 0x99, 0xf3, 0x0, 0x3, 0xf8, 0x5f, 0xa0, + 0x0, 0xaf, 0x40, 0xcf, 0xc8, 0xcf, 0xb0, 0x0, + 0x8e, 0xfd, 0x80, 0x0, + + /* U+03B1 "α" */ + 0x0, 0x2b, 0xff, 0xb3, 0x2f, 0xa0, 0x2f, 0xf7, + 0x49, 0xfa, 0xf6, 0xb, 0xf5, 0x0, 0x9, 0xff, + 0x21, 0xfe, 0x0, 0x0, 0x2f, 0xf0, 0x3f, 0xb0, + 0x0, 0x0, 0xfb, 0x4, 0xfa, 0x0, 0x0, 0xe, + 0x90, 0x3f, 0xb0, 0x0, 0x0, 0xfb, 0x0, 0xfe, + 0x0, 0x0, 0x3f, 0xe0, 0xb, 0xf5, 0x0, 0xb, + 0xff, 0x20, 0x2e, 0xe6, 0x4a, 0xf9, 0xf5, 0x0, + 0x2b, 0xff, 0xc3, 0x1f, 0xa0, + + /* U+03B2 "β" */ + 0x0, 0x6c, 0xfe, 0xa2, 0x0, 0xa, 0xfc, 0x8a, + 0xfe, 0x10, 0x4f, 0x90, 0x0, 0x4f, 0x80, 0x8f, + 0x30, 0x0, 0xf, 0xb0, 0x9f, 0x20, 0x0, 0x1f, + 0x80, 0xaf, 0x10, 0x25, 0xdd, 0x10, 0xaf, 0x15, + 0xff, 0xb1, 0x0, 0xaf, 0x11, 0x46, 0xdf, 0x50, + 0xaf, 0x10, 0x0, 0x1e, 0xf1, 0xaf, 0x20, 0x0, + 0x7, 0xf7, 0xaf, 0x20, 0x0, 0x4, 0xf9, 0xaf, + 0x50, 0x0, 0x5, 0xf7, 0xaf, 0xd0, 0x0, 0xc, + 0xf2, 0xaf, 0xdd, 0x76, 0xcf, 0x80, 0xaf, 0x28, + 0xef, 0xd7, 0x0, 0xaf, 0x10, 0x0, 0x0, 0x0, + 0xaf, 0x10, 0x0, 0x0, 0x0, 0xaf, 0x10, 0x0, + 0x0, 0x0, 0xaf, 0x10, 0x0, 0x0, 0x0, + + /* U+03B3 "γ" */ + 0x9f, 0x40, 0x0, 0x3, 0xf9, 0x3f, 0x90, 0x0, + 0x9, 0xf3, 0xd, 0xe0, 0x0, 0xe, 0xd0, 0x8, + 0xf4, 0x0, 0x4f, 0x70, 0x2, 0xf9, 0x0, 0x9f, + 0x20, 0x0, 0xce, 0x0, 0xec, 0x0, 0x0, 0x7f, + 0x44, 0xf6, 0x0, 0x0, 0x1f, 0xaa, 0xf1, 0x0, + 0x0, 0xb, 0xff, 0xb0, 0x0, 0x0, 0x6, 0xff, + 0x50, 0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0x0, + 0x0, 0xee, 0x0, 0x0, 0x0, 0x0, 0xee, 0x0, + 0x0, 0x0, 0x0, 0xee, 0x0, 0x0, 0x0, 0x0, + 0xee, 0x0, 0x0, + + /* U+03B4 "δ" */ + 0x4, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x2e, 0xfa, + 0x77, 0x77, 0x30, 0x0, 0x1c, 0xe3, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xf7, 0x0, 0x0, 0x0, 0x2a, + 0xff, 0xfb, 0x10, 0x0, 0x2e, 0xf9, 0x68, 0xfd, + 0x10, 0xb, 0xf6, 0x0, 0x4, 0xfa, 0x1, 0xfd, + 0x0, 0x0, 0xb, 0xf2, 0x3f, 0x90, 0x0, 0x0, + 0x7f, 0x54, 0xf8, 0x0, 0x0, 0x6, 0xf6, 0x3f, + 0xa0, 0x0, 0x0, 0x7f, 0x50, 0xfe, 0x0, 0x0, + 0xb, 0xf2, 0x9, 0xf8, 0x0, 0x5, 0xfc, 0x0, + 0x1d, 0xfc, 0x8b, 0xfe, 0x20, 0x0, 0x19, 0xef, + 0xe9, 0x10, 0x0, + + /* U+03B5 "ε" */ + 0x0, 0x5d, 0xfe, 0xa2, 0x0, 0x4f, 0xd9, 0xcf, + 0xc0, 0xa, 0xf1, 0x0, 0x31, 0x0, 0xaf, 0x20, + 0x0, 0x0, 0x3, 0xfe, 0x96, 0x0, 0x0, 0x1c, + 0xff, 0xb0, 0x0, 0xb, 0xf8, 0x10, 0x0, 0x0, + 0xfd, 0x0, 0x0, 0x0, 0xe, 0xe1, 0x0, 0x38, + 0x0, 0x8f, 0xd8, 0xaf, 0xf2, 0x0, 0x7d, 0xfe, + 0xa2, 0x0, + + /* U+03B6 "ζ" */ + 0x0, 0xbf, 0xff, 0xff, 0xa0, 0x5, 0x77, 0x8f, + 0xf4, 0x0, 0x0, 0x1b, 0xd2, 0x0, 0x0, 0xd, + 0xd1, 0x0, 0x0, 0xa, 0xe2, 0x0, 0x0, 0x7, + 0xf5, 0x0, 0x0, 0x1, 0xfb, 0x0, 0x0, 0x0, + 0x9f, 0x30, 0x0, 0x0, 0xe, 0xd0, 0x0, 0x0, + 0x2, 0xf9, 0x0, 0x0, 0x0, 0x4f, 0x70, 0x0, + 0x0, 0x3, 0xf9, 0x0, 0x0, 0x0, 0xf, 0xf5, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xeb, 0x40, 0x0, + 0x8e, 0xff, 0xff, 0x20, 0x0, 0x0, 0x9, 0xf6, + 0x0, 0x0, 0x0, 0x5f, 0x40, 0x0, 0x0, 0x9f, + 0xd0, 0x0, 0x0, 0x3e, 0xa1, 0x0, + + /* U+03B7 "η" */ + 0xaf, 0x2a, 0xef, 0xc4, 0xa, 0xfe, 0xb6, 0x7e, + 0xf3, 0xaf, 0xa0, 0x0, 0x4f, 0x9a, 0xf4, 0x0, + 0x0, 0xfb, 0xaf, 0x20, 0x0, 0xf, 0xca, 0xf1, + 0x0, 0x0, 0xfc, 0xaf, 0x10, 0x0, 0xf, 0xca, + 0xf1, 0x0, 0x0, 0xfc, 0xaf, 0x10, 0x0, 0xf, + 0xca, 0xf1, 0x0, 0x0, 0xfc, 0xaf, 0x10, 0x0, + 0xf, 0xc0, 0x0, 0x0, 0x0, 0xfc, 0x0, 0x0, + 0x0, 0xf, 0xc0, 0x0, 0x0, 0x0, 0xfc, 0x0, + 0x0, 0x0, 0xf, 0xc0, + + /* U+03B8 "θ" */ + 0x0, 0x7, 0xdf, 0xe8, 0x0, 0x0, 0xa, 0xfc, + 0x8b, 0xfb, 0x0, 0x3, 0xfb, 0x0, 0x9, 0xf5, + 0x0, 0x9f, 0x30, 0x0, 0x1f, 0xb0, 0xd, 0xf0, + 0x0, 0x0, 0xcf, 0x0, 0xfc, 0x0, 0x0, 0xa, + 0xf1, 0xf, 0xc2, 0x22, 0x22, 0xaf, 0x31, 0xff, + 0xff, 0xff, 0xff, 0xf3, 0xf, 0xd5, 0x55, 0x55, + 0xbf, 0x30, 0xfc, 0x0, 0x0, 0xa, 0xf1, 0xd, + 0xe0, 0x0, 0x0, 0xcf, 0x0, 0x9f, 0x30, 0x0, + 0x1f, 0xb0, 0x3, 0xfb, 0x0, 0x9, 0xf5, 0x0, + 0xa, 0xfc, 0x8b, 0xfb, 0x0, 0x0, 0x7, 0xdf, + 0xe8, 0x0, 0x0, + + /* U+03B9 "ι" */ + 0xaf, 0x1a, 0xf1, 0xaf, 0x1a, 0xf1, 0xaf, 0x1a, + 0xf1, 0xaf, 0x1a, 0xf1, 0xaf, 0x1a, 0xf1, 0xaf, + 0x10, + + /* U+03BA "κ" */ + 0xbf, 0x10, 0x4, 0xfe, 0x2b, 0xf1, 0x3, 0xfe, + 0x20, 0xbf, 0x13, 0xfe, 0x20, 0xb, 0xf4, 0xfe, + 0x20, 0x0, 0xbf, 0xff, 0x30, 0x0, 0xb, 0xff, + 0xfa, 0x0, 0x0, 0xbf, 0x2c, 0xf7, 0x0, 0xb, + 0xf1, 0x1e, 0xf4, 0x0, 0xbf, 0x10, 0x3f, 0xe1, + 0xb, 0xf1, 0x0, 0x6f, 0xc0, 0xbf, 0x10, 0x0, + 0xaf, 0x90, + + /* U+03BB "λ" */ + 0x0, 0x4f, 0x90, 0x0, 0x0, 0x0, 0xe, 0xe0, + 0x0, 0x0, 0x0, 0x9, 0xf4, 0x0, 0x0, 0x0, + 0x3, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, + 0x0, 0x0, 0x5, 0xff, 0x50, 0x0, 0x0, 0xb, + 0xff, 0xb0, 0x0, 0x0, 0x1f, 0xcd, 0xf1, 0x0, + 0x0, 0x6f, 0x67, 0xf6, 0x0, 0x0, 0xcf, 0x11, + 0xfc, 0x0, 0x2, 0xfb, 0x0, 0xbf, 0x20, 0x8, + 0xf5, 0x0, 0x6f, 0x70, 0xd, 0xf0, 0x0, 0xf, + 0xd0, 0x3f, 0xa0, 0x0, 0xa, 0xf3, 0x9f, 0x40, + 0x0, 0x4, 0xf9, + + /* U+03BC "μ" */ + 0xaf, 0x10, 0x0, 0xf, 0xca, 0xf1, 0x0, 0x0, + 0xfc, 0xaf, 0x10, 0x0, 0xf, 0xca, 0xf1, 0x0, + 0x0, 0xfc, 0xaf, 0x10, 0x0, 0xf, 0xca, 0xf1, + 0x0, 0x0, 0xfc, 0xaf, 0x20, 0x0, 0xf, 0xca, + 0xf4, 0x0, 0x3, 0xfc, 0xaf, 0xc0, 0x0, 0xbf, + 0xca, 0xff, 0xea, 0xef, 0xec, 0xaf, 0x5c, 0xfd, + 0x4d, 0xca, 0xf1, 0x0, 0x0, 0x0, 0xaf, 0x10, + 0x0, 0x0, 0xa, 0xf1, 0x0, 0x0, 0x0, 0xaf, + 0x10, 0x0, 0x0, 0x0, + + /* U+03BD "ν" */ + 0x9f, 0x40, 0x0, 0x3, 0xf9, 0x3f, 0x90, 0x0, + 0x9, 0xf3, 0xd, 0xe0, 0x0, 0xe, 0xd0, 0x7, + 0xf4, 0x0, 0x3f, 0x80, 0x2, 0xfa, 0x0, 0x9f, + 0x20, 0x0, 0xcf, 0x0, 0xec, 0x0, 0x0, 0x6f, + 0x44, 0xf7, 0x0, 0x0, 0x1f, 0x99, 0xf1, 0x0, + 0x0, 0xb, 0xee, 0xb0, 0x0, 0x0, 0x5, 0xff, + 0x60, 0x0, 0x0, 0x0, 0xff, 0x0, 0x0, + + /* U+03BE "ξ" */ + 0x0, 0x2a, 0xef, 0xf8, 0x0, 0x1e, 0xfa, 0x88, + 0x40, 0x8, 0xf4, 0x0, 0x0, 0x0, 0x7f, 0x30, + 0x0, 0x0, 0x1, 0xdf, 0xa8, 0x83, 0x0, 0x0, + 0x8f, 0xff, 0x60, 0x0, 0x5f, 0xc5, 0x10, 0x0, + 0x3f, 0xb0, 0x0, 0x0, 0xb, 0xf2, 0x0, 0x0, + 0x0, 0xfc, 0x0, 0x0, 0x0, 0x1f, 0xb0, 0x0, + 0x0, 0x0, 0xff, 0x10, 0x0, 0x0, 0x9, 0xfc, + 0x41, 0x0, 0x0, 0xb, 0xff, 0xfe, 0x60, 0x0, + 0x3, 0x8b, 0xff, 0x40, 0x0, 0x0, 0x4, 0xf8, + 0x0, 0x0, 0x0, 0x5f, 0x70, 0x0, 0x0, 0xcf, + 0xe1, 0x0, 0x0, 0x3e, 0x91, 0x0, + + /* U+03BF "ο" */ + 0x0, 0x18, 0xdf, 0xea, 0x20, 0x0, 0x1d, 0xfb, + 0x8b, 0xfe, 0x20, 0xa, 0xf7, 0x0, 0x5, 0xfc, + 0x0, 0xfd, 0x0, 0x0, 0xc, 0xf2, 0x3f, 0xa0, + 0x0, 0x0, 0x8f, 0x54, 0xf8, 0x0, 0x0, 0x6, + 0xf6, 0x3f, 0xa0, 0x0, 0x0, 0x7f, 0x50, 0xfd, + 0x0, 0x0, 0xb, 0xf2, 0xa, 0xf7, 0x0, 0x5, + 0xfc, 0x0, 0x1e, 0xfb, 0x8a, 0xfe, 0x20, 0x0, + 0x19, 0xef, 0xea, 0x20, 0x0, + + /* U+03C0 "π" */ + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x47, + 0x7e, 0xf7, 0x77, 0x7d, 0xf7, 0x72, 0x0, 0xd, + 0xf0, 0x0, 0xc, 0xf0, 0x0, 0x0, 0xd, 0xf0, + 0x0, 0xc, 0xf0, 0x0, 0x0, 0xd, 0xf0, 0x0, + 0xc, 0xf0, 0x0, 0x0, 0xd, 0xf0, 0x0, 0xc, + 0xf0, 0x0, 0x0, 0xd, 0xf0, 0x0, 0xc, 0xf0, + 0x0, 0x0, 0xd, 0xf0, 0x0, 0xc, 0xf0, 0x0, + 0x0, 0xd, 0xf0, 0x0, 0xc, 0xf0, 0x0, 0x0, + 0xd, 0xf0, 0x0, 0xc, 0xf0, 0x0, 0x0, 0xd, + 0xf0, 0x0, 0xc, 0xf0, 0x0, + + /* U+03C1 "ρ" */ + 0x0, 0x6d, 0xfe, 0xb3, 0x0, 0x8, 0xfe, 0x9a, + 0xff, 0x40, 0x2f, 0xd1, 0x0, 0x2e, 0xe0, 0x7f, + 0x50, 0x0, 0x7, 0xf6, 0xaf, 0x20, 0x0, 0x3, + 0xf9, 0xbf, 0x10, 0x0, 0x2, 0xfa, 0xbf, 0x20, + 0x0, 0x3, 0xf9, 0xbf, 0x50, 0x0, 0x7, 0xf6, + 0xbf, 0xd0, 0x0, 0x2e, 0xf0, 0xbf, 0xfd, 0x9a, + 0xff, 0x50, 0xbf, 0x3b, 0xff, 0xc4, 0x0, 0xbf, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0x0, 0x0, 0x0, 0x0, 0xbf, 0x0, + 0x0, 0x0, 0x0, + + /* U+03C2 "ς" */ + 0x0, 0x1, 0x8d, 0xff, 0xd3, 0x0, 0x3e, 0xfb, + 0x89, 0xb1, 0x2, 0xed, 0x20, 0x0, 0x0, 0xa, + 0xf2, 0x0, 0x0, 0x0, 0xf, 0xb0, 0x0, 0x0, + 0x0, 0x1f, 0x90, 0x0, 0x0, 0x0, 0x1f, 0xb0, + 0x0, 0x0, 0x0, 0xd, 0xf2, 0x0, 0x0, 0x0, + 0x5, 0xfe, 0x60, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xb5, 0x0, 0x0, 0x1, 0x6a, 0xef, 0x80, 0x0, + 0x0, 0x0, 0x1f, 0xe0, 0x0, 0x0, 0x0, 0x2f, + 0xe0, 0x0, 0x0, 0xbb, 0xff, 0x70, 0x0, 0x2, + 0xff, 0xc5, 0x0, + + /* U+03C3 "σ" */ + 0x0, 0x19, 0xef, 0xff, 0xff, 0xfe, 0x1, 0xef, + 0xec, 0xef, 0xfc, 0xba, 0xb, 0xf9, 0x0, 0x7, + 0xfa, 0x0, 0x1f, 0xe0, 0x0, 0x0, 0xdf, 0x10, + 0x4f, 0x90, 0x0, 0x0, 0x8f, 0x40, 0x5f, 0x80, + 0x0, 0x0, 0x7f, 0x50, 0x4f, 0x90, 0x0, 0x0, + 0x8f, 0x40, 0x1f, 0xc0, 0x0, 0x0, 0xcf, 0x20, + 0xb, 0xf6, 0x0, 0x5, 0xfc, 0x0, 0x1, 0xef, + 0xb8, 0xaf, 0xe2, 0x0, 0x0, 0x19, 0xef, 0xe9, + 0x10, 0x0, + + /* U+03C4 "τ" */ + 0x8f, 0xff, 0xff, 0xf7, 0x47, 0x7e, 0xf7, 0x73, + 0x0, 0xd, 0xf0, 0x0, 0x0, 0xd, 0xf0, 0x0, + 0x0, 0xd, 0xf0, 0x0, 0x0, 0xd, 0xf0, 0x0, + 0x0, 0xd, 0xf0, 0x0, 0x0, 0xd, 0xf0, 0x0, + 0x0, 0xd, 0xf0, 0x0, 0x0, 0xd, 0xf0, 0x0, + 0x0, 0xd, 0xf0, 0x0, + + /* U+03C5 "υ" */ + 0xaf, 0x10, 0x0, 0x2f, 0xaa, 0xf1, 0x0, 0x2, + 0xfa, 0xaf, 0x10, 0x0, 0x2f, 0xaa, 0xf1, 0x0, + 0x2, 0xfa, 0xaf, 0x10, 0x0, 0x2f, 0xaa, 0xf1, + 0x0, 0x2, 0xfa, 0xaf, 0x10, 0x0, 0x2f, 0x99, + 0xf3, 0x0, 0x3, 0xf8, 0x5f, 0xa0, 0x0, 0xaf, + 0x40, 0xcf, 0xc8, 0xcf, 0xb0, 0x0, 0x8e, 0xfd, + 0x80, 0x0, + + /* U+03C6 "φ" */ + 0x0, 0x2a, 0xb0, 0x8f, 0xeb, 0x20, 0x0, 0x1e, + 0xf6, 0x3f, 0xe9, 0xef, 0x20, 0xb, 0xf4, 0x4, + 0xf8, 0x2, 0xfb, 0x1, 0xfc, 0x0, 0x5f, 0x60, + 0xb, 0xf1, 0x3f, 0x90, 0x5, 0xf6, 0x0, 0x9f, + 0x34, 0xf9, 0x0, 0x5f, 0x60, 0xa, 0xf3, 0x2f, + 0xb0, 0x5, 0xf6, 0x0, 0xcf, 0x10, 0xef, 0x20, + 0x5f, 0x60, 0x3f, 0xb0, 0x6, 0xfd, 0x15, 0xf6, + 0x2d, 0xf3, 0x0, 0x9, 0xff, 0xcf, 0xdf, 0xf5, + 0x0, 0x0, 0x5, 0xcf, 0xff, 0xa2, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x5, 0xf6, 0x0, + 0x0, 0x0, + + /* U+03C7 "χ" */ + 0x4f, 0xa0, 0x0, 0x1, 0xfd, 0x0, 0xcf, 0x10, + 0x0, 0x8f, 0x50, 0x4, 0xf9, 0x0, 0x1f, 0xd0, + 0x0, 0xc, 0xf1, 0x8, 0xf5, 0x0, 0x0, 0x4f, + 0x81, 0xfc, 0x0, 0x0, 0x0, 0xcf, 0x9f, 0x40, + 0x0, 0x0, 0x5, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0xf, 0xf7, 0x0, 0x0, 0x0, 0x6, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0xed, 0x6f, 0x60, 0x0, 0x0, + 0x7f, 0x50, 0xee, 0x0, 0x0, 0xe, 0xd0, 0x6, + 0xf7, 0x0, 0x8, 0xf5, 0x0, 0xe, 0xe1, 0x1, + 0xfd, 0x0, 0x0, 0x6f, 0x80, 0x9f, 0x50, 0x0, + 0x0, 0xef, 0x10, + + /* U+03C8 "ψ" */ + 0xdf, 0x0, 0xc, 0xf0, 0x0, 0xbf, 0x1d, 0xf0, + 0x0, 0xcf, 0x0, 0xb, 0xf1, 0xdf, 0x0, 0xc, + 0xf0, 0x0, 0xbf, 0x1d, 0xf0, 0x0, 0xcf, 0x0, + 0xb, 0xf1, 0xdf, 0x0, 0xc, 0xf0, 0x0, 0xbf, + 0x1c, 0xf0, 0x0, 0xcf, 0x0, 0xb, 0xf0, 0xcf, + 0x0, 0xc, 0xf0, 0x0, 0xcf, 0xa, 0xf2, 0x0, + 0xcf, 0x0, 0xe, 0xe0, 0x5f, 0xb0, 0xc, 0xf0, + 0x7, 0xf9, 0x0, 0xaf, 0xe9, 0xef, 0x9c, 0xfd, + 0x10, 0x0, 0x6c, 0xff, 0xff, 0xd8, 0x10, 0x0, + 0x0, 0x0, 0xcf, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xf0, 0x0, + 0x0, 0x0, + + /* U+03C9 "ω" */ + 0x0, 0xde, 0x0, 0x0, 0x0, 0x4, 0xf7, 0x0, + 0x4f, 0x80, 0x0, 0x0, 0x0, 0xe, 0xe0, 0xa, + 0xf2, 0x0, 0x4, 0x30, 0x0, 0x8f, 0x40, 0xee, + 0x0, 0x1, 0xfb, 0x0, 0x4, 0xf8, 0x1f, 0xb0, + 0x0, 0x1f, 0xb0, 0x0, 0x1f, 0xb2, 0xfa, 0x0, + 0x1, 0xfb, 0x0, 0x0, 0xfb, 0x1f, 0xb0, 0x0, + 0x1f, 0xb0, 0x0, 0x1f, 0xb0, 0xfe, 0x0, 0x3, + 0xfc, 0x0, 0x4, 0xf9, 0xa, 0xf5, 0x0, 0x9e, + 0xf3, 0x0, 0xbf, 0x40, 0x2f, 0xf8, 0xaf, 0x4a, + 0xe8, 0xaf, 0xb0, 0x0, 0x3c, 0xfd, 0x50, 0x9, + 0xee, 0x90, 0x0, + + /* U+03CA "ϊ" */ + 0x8f, 0x40, 0xef, 0x8f, 0x40, 0xef, 0x1, 0x0, + 0x11, 0x0, 0x0, 0x0, 0x0, 0xaf, 0x10, 0x0, + 0xaf, 0x10, 0x0, 0xaf, 0x10, 0x0, 0xaf, 0x10, + 0x0, 0xaf, 0x10, 0x0, 0xaf, 0x10, 0x0, 0xaf, + 0x10, 0x0, 0xaf, 0x10, 0x0, 0xaf, 0x10, 0x0, + 0xaf, 0x10, 0x0, 0xaf, 0x10, + + /* U+03CB "ϋ" */ + 0x4, 0xf9, 0xa, 0xf3, 0x0, 0x4f, 0x90, 0xaf, + 0x30, 0x0, 0x10, 0x0, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0x10, 0x0, 0x2f, 0xaa, 0xf1, + 0x0, 0x2, 0xfa, 0xaf, 0x10, 0x0, 0x2f, 0xaa, + 0xf1, 0x0, 0x2, 0xfa, 0xaf, 0x10, 0x0, 0x2f, + 0xaa, 0xf1, 0x0, 0x2, 0xfa, 0xaf, 0x10, 0x0, + 0x2f, 0x99, 0xf3, 0x0, 0x3, 0xf8, 0x5f, 0xa0, + 0x0, 0xaf, 0x40, 0xcf, 0xc8, 0xcf, 0xb0, 0x0, + 0x8e, 0xfd, 0x80, 0x0, + + /* U+03CC "ό" */ + 0x0, 0x0, 0x8, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0xed, 0x0, 0x0, 0x0, 0x0, 0x5d, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x18, + 0xdf, 0xea, 0x20, 0x0, 0x1d, 0xfb, 0x8b, 0xfe, + 0x20, 0xa, 0xf7, 0x0, 0x5, 0xfc, 0x0, 0xfd, + 0x0, 0x0, 0xc, 0xf2, 0x3f, 0xa0, 0x0, 0x0, + 0x8f, 0x54, 0xf8, 0x0, 0x0, 0x6, 0xf6, 0x3f, + 0xa0, 0x0, 0x0, 0x7f, 0x50, 0xfd, 0x0, 0x0, + 0xb, 0xf2, 0xa, 0xf7, 0x0, 0x5, 0xfc, 0x0, + 0x1e, 0xfb, 0x8a, 0xfe, 0x20, 0x0, 0x19, 0xef, + 0xea, 0x20, 0x0, + + /* U+03CD "ύ" */ + 0x0, 0x0, 0x9f, 0x80, 0x0, 0x0, 0x1f, 0xc0, + 0x0, 0x0, 0x6, 0xc1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0x10, 0x0, 0x2f, 0xaa, 0xf1, + 0x0, 0x2, 0xfa, 0xaf, 0x10, 0x0, 0x2f, 0xaa, + 0xf1, 0x0, 0x2, 0xfa, 0xaf, 0x10, 0x0, 0x2f, + 0xaa, 0xf1, 0x0, 0x2, 0xfa, 0xaf, 0x10, 0x0, + 0x2f, 0x99, 0xf3, 0x0, 0x3, 0xf8, 0x5f, 0xa0, + 0x0, 0xaf, 0x40, 0xcf, 0xc8, 0xcf, 0xb0, 0x0, + 0x8e, 0xfd, 0x80, 0x0, + + /* U+03CE "ώ" */ + 0x0, 0x0, 0x0, 0x4, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2d, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xde, + 0x0, 0x0, 0x0, 0x4, 0xf7, 0x0, 0x4f, 0x80, + 0x0, 0x0, 0x0, 0xe, 0xe0, 0xa, 0xf2, 0x0, + 0x4, 0x30, 0x0, 0x8f, 0x40, 0xee, 0x0, 0x1, + 0xfb, 0x0, 0x4, 0xf8, 0x1f, 0xb0, 0x0, 0x1f, + 0xb0, 0x0, 0x1f, 0xb2, 0xfa, 0x0, 0x1, 0xfb, + 0x0, 0x0, 0xfb, 0x1f, 0xb0, 0x0, 0x1f, 0xb0, + 0x0, 0x1f, 0xb0, 0xfe, 0x0, 0x3, 0xfc, 0x0, + 0x4, 0xf9, 0xa, 0xf5, 0x0, 0x9e, 0xf3, 0x0, + 0xbf, 0x40, 0x2f, 0xf8, 0xaf, 0x4a, 0xe8, 0xaf, + 0xb0, 0x0, 0x3c, 0xfd, 0x50, 0x9, 0xee, 0x90, + 0x0, + + /* U+03F4 "ϴ" */ + 0x3f, 0x70, 0xea, 0xde, 0x3f, 0x78, 0xa0, 0xbd +}; + + +/*--------------------- + * GLYPH DESCRIPTION + *--------------------*/ + +static const lv_font_fmt_txt_glyph_dsc_t glyph_dsc[] = { + {.bitmap_index = 0, .adv_w = 0, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0} /* id = 0 reserved */, + {.bitmap_index = 0, .adv_w = 89, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 0, .adv_w = 89, .box_w = 3, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 23, .adv_w = 113, .box_w = 7, .box_h = 6, .ofs_x = 0, .ofs_y = 9}, + {.bitmap_index = 44, .adv_w = 178, .box_w = 11, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 127, .adv_w = 178, .box_w = 11, .box_h = 19, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 232, .adv_w = 285, .box_w = 16, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 352, .adv_w = 214, .box_w = 13, .box_h = 16, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 456, .adv_w = 61, .box_w = 3, .box_h = 6, .ofs_x = 0, .ofs_y = 9}, + {.bitmap_index = 465, .adv_w = 107, .box_w = 5, .box_h = 19, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 513, .adv_w = 107, .box_w = 6, .box_h = 19, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 570, .adv_w = 124, .box_w = 8, .box_h = 7, .ofs_x = 0, .ofs_y = 8}, + {.bitmap_index = 598, .adv_w = 187, .box_w = 10, .box_h = 10, .ofs_x = 1, .ofs_y = 2}, + {.bitmap_index = 648, .adv_w = 89, .box_w = 3, .box_h = 6, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 657, .adv_w = 107, .box_w = 7, .box_h = 2, .ofs_x = 0, .ofs_y = 4}, + {.bitmap_index = 664, .adv_w = 89, .box_w = 3, .box_h = 3, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 669, .adv_w = 89, .box_w = 6, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 714, .adv_w = 178, .box_w = 11, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 797, .adv_w = 178, .box_w = 6, .box_h = 15, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 842, .adv_w = 178, .box_w = 11, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 925, .adv_w = 178, .box_w = 11, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1008, .adv_w = 178, .box_w = 11, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1091, .adv_w = 178, .box_w = 11, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1174, .adv_w = 178, .box_w = 11, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1257, .adv_w = 178, .box_w = 11, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1340, .adv_w = 178, .box_w = 11, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1423, .adv_w = 178, .box_w = 11, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1506, .adv_w = 89, .box_w = 3, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1523, .adv_w = 89, .box_w = 3, .box_h = 14, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 1544, .adv_w = 187, .box_w = 10, .box_h = 11, .ofs_x = 1, .ofs_y = 2}, + {.bitmap_index = 1599, .adv_w = 187, .box_w = 10, .box_h = 6, .ofs_x = 1, .ofs_y = 5}, + {.bitmap_index = 1629, .adv_w = 187, .box_w = 10, .box_h = 11, .ofs_x = 1, .ofs_y = 2}, + {.bitmap_index = 1684, .adv_w = 178, .box_w = 11, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1767, .adv_w = 325, .box_w = 19, .box_h = 19, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 1948, .adv_w = 214, .box_w = 15, .box_h = 15, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 2061, .adv_w = 214, .box_w = 12, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2151, .adv_w = 231, .box_w = 13, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2249, .adv_w = 231, .box_w = 13, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2347, .adv_w = 214, .box_w = 12, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2437, .adv_w = 196, .box_w = 11, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2520, .adv_w = 249, .box_w = 14, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2625, .adv_w = 231, .box_w = 12, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2715, .adv_w = 89, .box_w = 3, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2738, .adv_w = 160, .box_w = 9, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2806, .adv_w = 214, .box_w = 13, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2904, .adv_w = 178, .box_w = 10, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2979, .adv_w = 267, .box_w = 15, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3092, .adv_w = 231, .box_w = 12, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3182, .adv_w = 249, .box_w = 15, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3295, .adv_w = 214, .box_w = 12, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3385, .adv_w = 249, .box_w = 15, .box_h = 16, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 3505, .adv_w = 231, .box_w = 14, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3610, .adv_w = 214, .box_w = 13, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3708, .adv_w = 196, .box_w = 12, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3798, .adv_w = 231, .box_w = 12, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3888, .adv_w = 214, .box_w = 14, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3993, .adv_w = 302, .box_w = 19, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4136, .adv_w = 214, .box_w = 14, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4241, .adv_w = 214, .box_w = 14, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4346, .adv_w = 196, .box_w = 12, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4436, .adv_w = 89, .box_w = 5, .box_h = 19, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 4484, .adv_w = 89, .box_w = 6, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4529, .adv_w = 89, .box_w = 5, .box_h = 19, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 4577, .adv_w = 150, .box_w = 9, .box_h = 8, .ofs_x = 0, .ofs_y = 7}, + {.bitmap_index = 4613, .adv_w = 178, .box_w = 13, .box_h = 3, .ofs_x = -1, .ofs_y = -5}, + {.bitmap_index = 4633, .adv_w = 107, .box_w = 5, .box_h = 3, .ofs_x = 0, .ofs_y = 12}, + {.bitmap_index = 4641, .adv_w = 178, .box_w = 11, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4702, .adv_w = 178, .box_w = 10, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4777, .adv_w = 160, .box_w = 10, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4832, .adv_w = 178, .box_w = 10, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4907, .adv_w = 178, .box_w = 11, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4968, .adv_w = 89, .box_w = 7, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5021, .adv_w = 178, .box_w = 10, .box_h = 15, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 5096, .adv_w = 178, .box_w = 9, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 5164, .adv_w = 71, .box_w = 3, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 5187, .adv_w = 71, .box_w = 5, .box_h = 19, .ofs_x = -1, .ofs_y = -4}, + {.bitmap_index = 5235, .adv_w = 160, .box_w = 9, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 5303, .adv_w = 71, .box_w = 3, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 5326, .adv_w = 267, .box_w = 15, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 5409, .adv_w = 178, .box_w = 9, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 5459, .adv_w = 178, .box_w = 11, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5520, .adv_w = 178, .box_w = 10, .box_h = 15, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 5595, .adv_w = 178, .box_w = 10, .box_h = 15, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 5670, .adv_w = 107, .box_w = 6, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 5703, .adv_w = 160, .box_w = 10, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5758, .adv_w = 89, .box_w = 6, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5803, .adv_w = 178, .box_w = 9, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 5853, .adv_w = 160, .box_w = 10, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5908, .adv_w = 231, .box_w = 15, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5991, .adv_w = 160, .box_w = 10, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6046, .adv_w = 160, .box_w = 10, .box_h = 15, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 6121, .adv_w = 160, .box_w = 10, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6176, .adv_w = 107, .box_w = 7, .box_h = 19, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 6243, .adv_w = 83, .box_w = 3, .box_h = 19, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 6272, .adv_w = 107, .box_w = 7, .box_h = 19, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 6339, .adv_w = 187, .box_w = 11, .box_h = 5, .ofs_x = 0, .ofs_y = 5}, + {.bitmap_index = 6367, .adv_w = 89, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6367, .adv_w = 178, .box_w = 11, .box_h = 16, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 6455, .adv_w = 178, .box_w = 11, .box_h = 11, .ofs_x = 0, .ofs_y = 2}, + {.bitmap_index = 6516, .adv_w = 178, .box_w = 12, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6606, .adv_w = 83, .box_w = 3, .box_h = 19, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 6635, .adv_w = 178, .box_w = 11, .box_h = 19, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 6740, .adv_w = 107, .box_w = 7, .box_h = 3, .ofs_x = 0, .ofs_y = 13}, + {.bitmap_index = 6751, .adv_w = 236, .box_w = 15, .box_h = 17, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 6879, .adv_w = 120, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 7}, + {.bitmap_index = 6911, .adv_w = 178, .box_w = 9, .box_h = 10, .ofs_x = 1, .ofs_y = 1}, + {.bitmap_index = 6956, .adv_w = 187, .box_w = 10, .box_h = 7, .ofs_x = 1, .ofs_y = 4}, + {.bitmap_index = 6991, .adv_w = 107, .box_w = 7, .box_h = 2, .ofs_x = 0, .ofs_y = 4}, + {.bitmap_index = 6998, .adv_w = 236, .box_w = 15, .box_h = 17, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 7126, .adv_w = 128, .box_w = 6, .box_h = 7, .ofs_x = 1, .ofs_y = 9}, + {.bitmap_index = 7147, .adv_w = 187, .box_w = 10, .box_h = 13, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 7212, .adv_w = 107, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 7}, + {.bitmap_index = 7240, .adv_w = 107, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 7}, + {.bitmap_index = 7268, .adv_w = 178, .box_w = 9, .box_h = 15, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 7336, .adv_w = 172, .box_w = 12, .box_h = 19, .ofs_x = -1, .ofs_y = -4}, + {.bitmap_index = 7450, .adv_w = 90, .box_w = 3, .box_h = 3, .ofs_x = 1, .ofs_y = 6}, + {.bitmap_index = 7455, .adv_w = 178, .box_w = 9, .box_h = 10, .ofs_x = 1, .ofs_y = 1}, + {.bitmap_index = 7500, .adv_w = 267, .box_w = 16, .box_h = 16, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 7628, .adv_w = 107, .box_w = 4, .box_h = 3, .ofs_x = 2, .ofs_y = 12}, + {.bitmap_index = 7634, .adv_w = 214, .box_w = 15, .box_h = 15, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 7747, .adv_w = 251, .box_w = 16, .box_h = 15, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 7867, .adv_w = 268, .box_w = 16, .box_h = 15, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 7987, .adv_w = 123, .box_w = 7, .box_h = 15, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 8040, .adv_w = 248, .box_w = 16, .box_h = 15, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 8160, .adv_w = 274, .box_w = 18, .box_h = 15, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 8295, .adv_w = 241, .box_w = 16, .box_h = 15, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 8415, .adv_w = 71, .box_w = 8, .box_h = 15, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 8475, .adv_w = 214, .box_w = 15, .box_h = 15, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 8588, .adv_w = 214, .box_w = 12, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 8678, .adv_w = 176, .box_w = 10, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 8753, .adv_w = 214, .box_w = 15, .box_h = 15, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 8866, .adv_w = 214, .box_w = 12, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 8956, .adv_w = 196, .box_w = 12, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 9046, .adv_w = 231, .box_w = 12, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 9136, .adv_w = 249, .box_w = 15, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 9249, .adv_w = 89, .box_w = 3, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 9272, .adv_w = 214, .box_w = 13, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 9370, .adv_w = 214, .box_w = 14, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 9475, .adv_w = 267, .box_w = 15, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 9588, .adv_w = 231, .box_w = 12, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 9678, .adv_w = 208, .box_w = 11, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 9761, .adv_w = 249, .box_w = 15, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 9874, .adv_w = 231, .box_w = 12, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 9964, .adv_w = 214, .box_w = 12, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 10054, .adv_w = 198, .box_w = 11, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 10137, .adv_w = 196, .box_w = 12, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 10227, .adv_w = 214, .box_w = 14, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 10332, .adv_w = 255, .box_w = 16, .box_h = 16, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 10460, .adv_w = 214, .box_w = 14, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 10565, .adv_w = 267, .box_w = 15, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 10678, .adv_w = 239, .box_w = 15, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 10791, .adv_w = 89, .box_w = 7, .box_h = 18, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 10854, .adv_w = 214, .box_w = 14, .box_h = 18, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 10980, .adv_w = 185, .box_w = 11, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 11063, .adv_w = 143, .box_w = 9, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 11131, .adv_w = 178, .box_w = 9, .box_h = 19, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 11217, .adv_w = 71, .box_w = 4, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 11247, .adv_w = 175, .box_w = 9, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 11315, .adv_w = 185, .box_w = 11, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 11376, .adv_w = 184, .box_w = 10, .box_h = 19, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 11471, .adv_w = 160, .box_w = 10, .box_h = 15, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 11546, .adv_w = 178, .box_w = 11, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 11629, .adv_w = 143, .box_w = 9, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 11679, .adv_w = 141, .box_w = 9, .box_h = 19, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 11765, .adv_w = 178, .box_w = 9, .box_h = 15, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 11833, .adv_w = 178, .box_w = 11, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 11916, .adv_w = 71, .box_w = 3, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 11933, .adv_w = 159, .box_w = 9, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 11983, .adv_w = 160, .box_w = 10, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 12058, .adv_w = 178, .box_w = 9, .box_h = 15, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 12126, .adv_w = 160, .box_w = 10, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 12181, .adv_w = 143, .box_w = 9, .box_h = 19, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 12267, .adv_w = 178, .box_w = 11, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 12328, .adv_w = 221, .box_w = 14, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 12405, .adv_w = 182, .box_w = 10, .box_h = 15, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 12480, .adv_w = 154, .box_w = 10, .box_h = 15, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 12555, .adv_w = 198, .box_w = 12, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 12621, .adv_w = 126, .box_w = 8, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 12665, .adv_w = 175, .box_w = 9, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 12715, .adv_w = 208, .box_w = 13, .box_h = 15, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 12813, .adv_w = 168, .box_w = 11, .box_h = 15, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 12896, .adv_w = 228, .box_w = 13, .box_h = 15, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 12994, .adv_w = 250, .box_w = 15, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 13077, .adv_w = 71, .box_w = 6, .box_h = 15, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 13122, .adv_w = 175, .box_w = 9, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 13190, .adv_w = 178, .box_w = 11, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 13273, .adv_w = 175, .box_w = 9, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 13341, .adv_w = 250, .box_w = 15, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 13454, .adv_w = 107, .box_w = 8, .box_h = 2, .ofs_x = -1, .ofs_y = 13} +}; + +/*--------------------- + * CHARACTER MAPPING + *--------------------*/ + +static const uint8_t glyph_id_ofs_list_1[] = { + 0, 0, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 0, + 13, 14, 15, 16, 0, 17, 18, 19, + 0, 0, 0, 20, 0, 21 +}; + +static const uint8_t glyph_id_ofs_list_2[] = { + 0, 0, 1, 0, 2, 3, 4, 0, + 5 +}; + +/*Collect the unicode lists and glyph_id offsets*/ +static const lv_font_fmt_txt_cmap_t cmaps[] = +{ + { + .range_start = 32, .range_length = 95, .glyph_id_start = 1, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 160, .range_length = 30, .glyph_id_start = 96, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_1, .list_length = 30, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 900, .range_length = 9, .glyph_id_start = 118, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_2, .list_length = 9, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 910, .range_length = 20, .glyph_id_start = 124, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 931, .range_length = 44, .glyph_id_start = 144, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 1012, .range_length = 1, .glyph_id_start = 188, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + } +}; + + + +/*-------------------- + * ALL CUSTOM DATA + *--------------------*/ + +#if LVGL_VERSION_MAJOR == 8 +/*Store all the custom data of the font*/ +static lv_font_fmt_txt_glyph_cache_t cache; +#endif + +#if LVGL_VERSION_MAJOR >= 8 +static const lv_font_fmt_txt_dsc_t font_dsc = { +#else +static lv_font_fmt_txt_dsc_t font_dsc = { +#endif + .glyph_bitmap = glyph_bitmap, + .glyph_dsc = glyph_dsc, + .cmaps = cmaps, + .kern_dsc = NULL, + .kern_scale = 0, + .cmap_num = 6, + .bpp = 4, + .kern_classes = 0, + .bitmap_format = 0, +#if LVGL_VERSION_MAJOR == 8 + .cache = &cache +#endif + +}; + +extern const lv_font_t lv_font_montserrat_20; + + +/*----------------- + * PUBLIC FONT + *----------------*/ + +/*Initialize a public general font descriptor*/ +#if LVGL_VERSION_MAJOR >= 8 +const lv_font_t lv_font_arial_20 = { +#else +lv_font_t lv_font_arial_20 = { +#endif + .get_glyph_dsc = lv_font_get_glyph_dsc_fmt_txt, /*Function pointer to get glyph's data*/ + .get_glyph_bitmap = lv_font_get_bitmap_fmt_txt, /*Function pointer to get glyph's bitmap*/ + .line_height = 23, /*The maximum line height required by the font*/ + .base_line = 5, /*Baseline measured from the bottom of the line*/ +#if !(LVGL_VERSION_MAJOR == 6 && LVGL_VERSION_MINOR == 0) + .subpx = LV_FONT_SUBPX_NONE, +#endif +#if LV_VERSION_CHECK(7, 4, 0) || LVGL_VERSION_MAJOR >= 8 + .underline_position = -2, + .underline_thickness = 1, +#endif + //.static_bitmap = 0, + .dsc = &font_dsc, /*The custom font data. Will be accessed by `get_glyph_bitmap/dsc` */ +#if LV_VERSION_CHECK(8, 2, 0) || LVGL_VERSION_MAJOR >= 9 + .fallback = &lv_font_montserrat_20, +#endif + .user_data = NULL, +}; + + + +#endif /*#if LV_FONT_ARIAL_20*/ diff --git a/src/fonts/lv_font_arial_22.c b/src/fonts/lv_font_arial_22.c new file mode 100644 index 0000000000..ff9fa5a465 --- /dev/null +++ b/src/fonts/lv_font_arial_22.c @@ -0,0 +1,2710 @@ +/******************************************************************************* + * Size: 22 px + * Bpp: 4 + * Opts: --bpp 4 --size 22 --no-compress --stride 1 --align 1 --font Arial Greek Regular.ttf --range 32-127,160-255,880-1023 --format lvgl -o lv_font_arial_22.c + ******************************************************************************/ + +#ifdef __has_include + #if __has_include("lvgl.h") + #ifndef LV_LVGL_H_INCLUDE_SIMPLE + #define LV_LVGL_H_INCLUDE_SIMPLE + #endif + #endif +#endif + +#ifdef LV_LVGL_H_INCLUDE_SIMPLE + #include "lvgl.h" +#else + #include "lvgl/lvgl.h" +#endif + + + +#ifndef LV_FONT_ARIAL_22 +#define LV_FONT_ARIAL_22 1 +#endif + +#if LV_FONT_ARIAL_22 + +/*----------------- + * BITMAPS + *----------------*/ + +/*Store the image of the glyphs*/ +static LV_ATTRIBUTE_LARGE_CONST const uint8_t glyph_bitmap[] = { + /* U+0020 " " */ + + /* U+0021 "!" */ + 0x2f, 0xf4, 0x2f, 0xf4, 0x2f, 0xf4, 0x2f, 0xf3, + 0x1f, 0xf3, 0xf, 0xf2, 0xf, 0xf1, 0xd, 0xf0, + 0xc, 0xe0, 0xb, 0xd0, 0xa, 0xc0, 0x9, 0xb0, + 0x1, 0x10, 0x4, 0x40, 0x1f, 0xf2, 0x1f, 0xf2, + + /* U+0022 "\"" */ + 0xff, 0x36, 0xfc, 0xff, 0x36, 0xfc, 0xff, 0x36, + 0xfc, 0xdf, 0x14, 0xfa, 0xae, 0x1, 0xf7, 0x59, + 0x0, 0xb4, + + /* U+0023 "#" */ + 0x0, 0x0, 0xaf, 0x0, 0xa, 0xf0, 0x0, 0x0, + 0xeb, 0x0, 0xe, 0xb0, 0x0, 0x2, 0xf7, 0x0, + 0x2f, 0x70, 0x0, 0x5, 0xf4, 0x0, 0x5f, 0x40, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7a, 0xaf, + 0xea, 0xaa, 0xfe, 0xaa, 0x0, 0xf, 0xa0, 0x0, + 0xfa, 0x0, 0x0, 0x3f, 0x60, 0x3, 0xf6, 0x0, + 0x0, 0x6f, 0x30, 0x6, 0xf3, 0x0, 0x7a, 0xdf, + 0xaa, 0xad, 0xfa, 0xaa, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x0, 0xf9, 0x0, 0xf, 0x90, 0x0, + 0x3, 0xf6, 0x0, 0x3f, 0x60, 0x0, 0x6, 0xf3, + 0x0, 0x6f, 0x30, 0x0, 0x9, 0xf0, 0x0, 0x9f, + 0x0, 0x0, 0xc, 0xd0, 0x0, 0xcd, 0x0, 0x0, + + /* U+0024 "$" */ + 0x0, 0x0, 0x7, 0xa0, 0x0, 0x0, 0x0, 0x8, + 0xdf, 0xfd, 0x80, 0x0, 0x0, 0xcf, 0xed, 0xee, + 0xfc, 0x0, 0x6, 0xfc, 0x17, 0xa1, 0xdf, 0x60, + 0xb, 0xf4, 0x7, 0xa0, 0x5f, 0xb0, 0xd, 0xf2, + 0x7, 0xa0, 0x2, 0x0, 0xb, 0xf6, 0x7, 0xa0, + 0x0, 0x0, 0x6, 0xff, 0x57, 0xa0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xd6, 0x10, 0x0, 0x0, 0x5, + 0xbf, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x7, 0xca, + 0xff, 0x70, 0x0, 0x0, 0x7, 0xa0, 0x5f, 0xf0, + 0x0, 0x10, 0x7, 0xa0, 0xd, 0xf3, 0x1e, 0xe0, + 0x7, 0xa0, 0xc, 0xf3, 0xf, 0xf3, 0x7, 0xa0, + 0xf, 0xf1, 0x9, 0xfc, 0x17, 0xa0, 0xaf, 0xa0, + 0x1, 0xdf, 0xed, 0xee, 0xfe, 0x10, 0x0, 0x8, + 0xdf, 0xfe, 0x91, 0x0, 0x0, 0x0, 0x7, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xa0, 0x0, 0x0, + + /* U+0025 "%" */ + 0x3, 0xcf, 0xd7, 0x0, 0x0, 0x0, 0xe9, 0x0, + 0x0, 0x2f, 0xd6, 0x9f, 0x70, 0x0, 0x8, 0xf1, + 0x0, 0x0, 0x8f, 0x30, 0xc, 0xe0, 0x0, 0x1f, + 0x80, 0x0, 0x0, 0xaf, 0x0, 0xa, 0xf0, 0x0, + 0x9e, 0x10, 0x0, 0x0, 0x8f, 0x10, 0xc, 0xf0, + 0x2, 0xf7, 0x0, 0x0, 0x0, 0x3f, 0xa2, 0x5f, + 0xa0, 0xa, 0xe0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xfb, 0x10, 0x3f, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x13, 0x20, 0x0, 0xbd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xf5, 0x2, 0xcf, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xc0, 0xd, 0xe6, + 0x7f, 0x90, 0x0, 0x0, 0x0, 0x5f, 0x30, 0x4f, + 0x60, 0xa, 0xf0, 0x0, 0x0, 0x0, 0xdb, 0x0, + 0x7f, 0x30, 0x7, 0xf2, 0x0, 0x0, 0x6, 0xf2, + 0x0, 0x7f, 0x30, 0x7, 0xf2, 0x0, 0x0, 0xe, + 0xa0, 0x0, 0x4f, 0x60, 0xb, 0xf0, 0x0, 0x0, + 0x8f, 0x20, 0x0, 0xd, 0xe7, 0x8f, 0x80, 0x0, + 0x1, 0xf9, 0x0, 0x0, 0x1, 0xbf, 0xe8, 0x0, + + /* U+0026 "&" */ + 0x0, 0x0, 0x4c, 0xfe, 0x91, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xfb, 0xdf, 0xd0, 0x0, 0x0, 0x0, + 0xe, 0xf3, 0x0, 0xcf, 0x50, 0x0, 0x0, 0x0, + 0xff, 0x0, 0x8, 0xf7, 0x0, 0x0, 0x0, 0xd, + 0xf4, 0x0, 0xcf, 0x30, 0x0, 0x0, 0x0, 0x5f, + 0xe2, 0x9f, 0x90, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xd4, 0xef, + 0xa0, 0x7, 0x40, 0x0, 0x7f, 0xd1, 0x2, 0xff, + 0x73, 0xfe, 0x0, 0xe, 0xf3, 0x0, 0x5, 0xff, + 0xcf, 0x80, 0x0, 0xff, 0x10, 0x0, 0x7, 0xff, + 0xf1, 0x0, 0xe, 0xf5, 0x0, 0x0, 0x1e, 0xfe, + 0x10, 0x0, 0x7f, 0xe3, 0x0, 0x3d, 0xff, 0xfd, + 0x10, 0x0, 0xbf, 0xfd, 0xdf, 0xfb, 0x1d, 0xfe, + 0x0, 0x0, 0x7d, 0xff, 0xc5, 0x0, 0x1c, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0027 "'" */ + 0xff, 0x3f, 0xf3, 0xff, 0x3d, 0xf1, 0xbe, 0x6, + 0x80, + + /* U+0028 "(" */ + 0x0, 0x3, 0xf3, 0x0, 0xd, 0xa0, 0x0, 0x8f, + 0x20, 0x1, 0xfb, 0x0, 0x7, 0xf4, 0x0, 0xd, + 0xf0, 0x0, 0x2f, 0xb0, 0x0, 0x6f, 0x80, 0x0, + 0x8f, 0x60, 0x0, 0xaf, 0x50, 0x0, 0xaf, 0x50, + 0x0, 0x8f, 0x60, 0x0, 0x6f, 0x80, 0x0, 0x2f, + 0xc0, 0x0, 0xe, 0xf0, 0x0, 0x8, 0xf5, 0x0, + 0x1, 0xfb, 0x0, 0x0, 0x8f, 0x20, 0x0, 0xd, + 0xa0, 0x0, 0x3, 0xf4, + + /* U+0029 ")" */ + 0xe, 0x80, 0x0, 0x5, 0xf3, 0x0, 0x0, 0xdd, + 0x0, 0x0, 0x6f, 0x50, 0x0, 0xf, 0xd0, 0x0, + 0xa, 0xf3, 0x0, 0x7, 0xf7, 0x0, 0x3, 0xfb, + 0x0, 0x1, 0xfd, 0x0, 0x0, 0xff, 0x0, 0x0, + 0xff, 0x0, 0x2, 0xfe, 0x0, 0x3, 0xfc, 0x0, + 0x7, 0xf8, 0x0, 0xb, 0xf3, 0x0, 0xf, 0xd0, + 0x0, 0x6f, 0x50, 0x0, 0xdd, 0x0, 0x5, 0xf3, + 0x0, 0xe, 0x80, 0x0, + + /* U+002A "*" */ + 0x0, 0x7, 0xf0, 0x0, 0x2, 0x6, 0xf0, 0x1, + 0xf, 0xda, 0xe9, 0xf9, 0x16, 0xaf, 0xfd, 0x94, + 0x0, 0x3f, 0xdb, 0x0, 0x2, 0xeb, 0x3f, 0x90, + 0x0, 0x92, 0x7, 0x50, + + /* U+002B "+" */ + 0x0, 0x0, 0x5b, 0x30, 0x0, 0x0, 0x0, 0x7, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x7f, 0x50, 0x0, + 0x0, 0x0, 0x7, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0x50, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0xad, 0xdd, 0xef, 0xed, 0xdd, 0x80, 0x0, + 0x7, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x7f, 0x50, + 0x0, 0x0, 0x0, 0x7, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0x50, 0x0, 0x0, + + /* U+002C "," */ + 0x4, 0x40, 0x1f, 0xf1, 0x1f, 0xf1, 0x0, 0xf0, + 0x5, 0xd0, 0xe, 0x40, 0x0, 0x0, + + /* U+002D "-" */ + 0x4f, 0xff, 0xff, 0xa4, 0xff, 0xff, 0xfa, + + /* U+002E "." */ + 0x4, 0x40, 0xf, 0xf2, 0xf, 0xf2, + + /* U+002F "/" */ + 0x0, 0x0, 0x9f, 0x0, 0x0, 0xd, 0xa0, 0x0, + 0x2, 0xf6, 0x0, 0x0, 0x7f, 0x10, 0x0, 0xb, + 0xd0, 0x0, 0x0, 0xf8, 0x0, 0x0, 0x4f, 0x40, + 0x0, 0x9, 0xf0, 0x0, 0x0, 0xdb, 0x0, 0x0, + 0x2f, 0x60, 0x0, 0x6, 0xf2, 0x0, 0x0, 0xbd, + 0x0, 0x0, 0xf, 0x80, 0x0, 0x4, 0xf4, 0x0, + 0x0, 0x9f, 0x0, 0x0, 0xd, 0xb0, 0x0, 0x0, + + /* U+0030 "0" */ + 0x0, 0x4, 0xbe, 0xfc, 0x50, 0x0, 0x0, 0x5f, + 0xfb, 0xbf, 0xf8, 0x0, 0x1, 0xff, 0x30, 0x2, + 0xef, 0x30, 0x6, 0xf9, 0x0, 0x0, 0x6f, 0x90, + 0xb, 0xf4, 0x0, 0x0, 0x1f, 0xe0, 0xe, 0xf1, + 0x0, 0x0, 0xe, 0xf0, 0xf, 0xf0, 0x0, 0x0, + 0xd, 0xf2, 0xf, 0xf0, 0x0, 0x0, 0xc, 0xf3, + 0xf, 0xf0, 0x0, 0x0, 0xc, 0xf3, 0xf, 0xf0, + 0x0, 0x0, 0xd, 0xf2, 0xe, 0xf1, 0x0, 0x0, + 0xe, 0xf0, 0xb, 0xf4, 0x0, 0x0, 0x1f, 0xe0, + 0x6, 0xf9, 0x0, 0x0, 0x6f, 0x90, 0x1, 0xff, + 0x40, 0x2, 0xef, 0x30, 0x0, 0x5f, 0xfb, 0xbf, + 0xf8, 0x0, 0x0, 0x4, 0xbf, 0xfc, 0x50, 0x0, + + /* U+0031 "1" */ + 0x0, 0x0, 0x5f, 0x30, 0x0, 0x2e, 0xf3, 0x0, + 0x4e, 0xff, 0x31, 0x9f, 0xfe, 0xf3, 0x9f, 0xd3, + 0xbf, 0x36, 0x60, 0xb, 0xf3, 0x0, 0x0, 0xbf, + 0x30, 0x0, 0xb, 0xf3, 0x0, 0x0, 0xbf, 0x30, + 0x0, 0xb, 0xf3, 0x0, 0x0, 0xbf, 0x30, 0x0, + 0xb, 0xf3, 0x0, 0x0, 0xbf, 0x30, 0x0, 0xb, + 0xf3, 0x0, 0x0, 0xbf, 0x30, 0x0, 0xb, 0xf3, + + /* U+0032 "2" */ + 0x0, 0x6, 0xcf, 0xfd, 0x81, 0x0, 0x0, 0xaf, + 0xfc, 0xbe, 0xfd, 0x10, 0x6, 0xfd, 0x20, 0x0, + 0xbf, 0xa0, 0xc, 0xf4, 0x0, 0x0, 0x1f, 0xf0, + 0x9, 0xc1, 0x0, 0x0, 0xf, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0x80, 0x0, 0x0, 0x0, 0x7, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x7f, 0xf3, 0x0, 0x0, 0x0, + 0x8, 0xfe, 0x30, 0x0, 0x0, 0x0, 0xaf, 0xd2, + 0x0, 0x0, 0x0, 0xb, 0xfc, 0x10, 0x0, 0x0, + 0x0, 0xbf, 0xb0, 0x0, 0x0, 0x0, 0x7, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xee, 0xee, + 0xee, 0xe1, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xf1, + + /* U+0033 "3" */ + 0x0, 0x6, 0xcf, 0xfc, 0x50, 0x0, 0x0, 0x9f, + 0xeb, 0xbf, 0xf8, 0x0, 0x4, 0xfd, 0x10, 0x2, + 0xef, 0x20, 0xa, 0xf5, 0x0, 0x0, 0x9f, 0x70, + 0x1, 0x30, 0x0, 0x0, 0x9f, 0x60, 0x0, 0x0, + 0x0, 0x3, 0xff, 0x20, 0x0, 0x0, 0x8, 0xbf, + 0xe5, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xd6, 0x0, + 0x0, 0x0, 0x1, 0x15, 0xef, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xf3, 0x8, 0xa0, 0x0, 0x0, 0xd, 0xf3, + 0xd, 0xf4, 0x0, 0x0, 0x2f, 0xf1, 0x6, 0xfd, + 0x10, 0x1, 0xcf, 0x90, 0x0, 0xaf, 0xfb, 0xbf, + 0xfb, 0x0, 0x0, 0x6, 0xcf, 0xfc, 0x60, 0x0, + + /* U+0034 "4" */ + 0x0, 0x0, 0x0, 0xd, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xf1, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x1e, 0xde, 0xf1, 0x0, + 0x0, 0x0, 0xaf, 0x3d, 0xf1, 0x0, 0x0, 0x5, + 0xf7, 0xd, 0xf1, 0x0, 0x0, 0x2f, 0xc0, 0xd, + 0xf1, 0x0, 0x0, 0xcf, 0x20, 0xd, 0xf1, 0x0, + 0x7, 0xf6, 0x0, 0xd, 0xf1, 0x0, 0x3f, 0xa0, + 0x0, 0xd, 0xf1, 0x0, 0xaf, 0xed, 0xdd, 0xdf, + 0xfd, 0xd2, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0xd, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0xd, 0xf1, 0x0, + + /* U+0035 "5" */ + 0x0, 0x4f, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x7f, + 0xee, 0xee, 0xee, 0x90, 0x0, 0xaf, 0x30, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x3, 0xfb, + 0x8d, 0xfd, 0x80, 0x0, 0x6, 0xff, 0xfc, 0xdf, + 0xfd, 0x10, 0x9, 0xfc, 0x10, 0x2, 0xdf, 0xb0, + 0x1, 0x31, 0x0, 0x0, 0x2f, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xf5, 0x8, 0xa0, 0x0, 0x0, 0xd, 0xf4, + 0xd, 0xf5, 0x0, 0x0, 0x3f, 0xe0, 0x7, 0xfe, + 0x20, 0x1, 0xcf, 0x70, 0x0, 0xbf, 0xfb, 0xbf, + 0xfb, 0x0, 0x0, 0x6, 0xcf, 0xfc, 0x60, 0x0, + + /* U+0036 "6" */ + 0x0, 0x1, 0x9e, 0xfd, 0x91, 0x0, 0x0, 0x2e, + 0xfc, 0xad, 0xfe, 0x10, 0x0, 0xdf, 0x50, 0x0, + 0x9f, 0xa0, 0x5, 0xfa, 0x0, 0x0, 0x1d, 0xb0, + 0xa, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xd, 0xf0, + 0x39, 0xba, 0x50, 0x0, 0xf, 0xe6, 0xff, 0xff, + 0xfa, 0x0, 0xf, 0xff, 0xa2, 0x4, 0xef, 0x80, + 0x1f, 0xfb, 0x0, 0x0, 0x3f, 0xf0, 0xf, 0xf4, + 0x0, 0x0, 0xd, 0xf3, 0xf, 0xf2, 0x0, 0x0, + 0xb, 0xf4, 0xc, 0xf4, 0x0, 0x0, 0xc, 0xf3, + 0x8, 0xfa, 0x0, 0x0, 0x1f, 0xf0, 0x1, 0xff, + 0x50, 0x0, 0xbf, 0x80, 0x0, 0x4f, 0xfc, 0xae, + 0xfc, 0x0, 0x0, 0x2, 0xae, 0xfd, 0x80, 0x0, + + /* U+0037 "7" */ + 0xef, 0xff, 0xff, 0xff, 0xff, 0x4d, 0xee, 0xee, + 0xee, 0xef, 0xf3, 0x0, 0x0, 0x0, 0xa, 0xf7, + 0x0, 0x0, 0x0, 0x6, 0xfc, 0x0, 0x0, 0x0, + 0x1, 0xff, 0x20, 0x0, 0x0, 0x0, 0xaf, 0x80, + 0x0, 0x0, 0x0, 0x2f, 0xf1, 0x0, 0x0, 0x0, + 0x9, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x6f, 0xb0, 0x0, 0x0, 0x0, + 0xb, 0xf5, 0x0, 0x0, 0x0, 0x0, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x4f, 0xc0, 0x0, 0x0, 0x0, + 0x7, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x9f, 0x70, + 0x0, 0x0, 0x0, 0xa, 0xf5, 0x0, 0x0, 0x0, + + /* U+0038 "8" */ + 0x0, 0x5, 0xcf, 0xfd, 0x70, 0x0, 0x0, 0x7f, + 0xfb, 0xbf, 0xfb, 0x0, 0x2, 0xff, 0x20, 0x1, + 0xdf, 0x60, 0x6, 0xf9, 0x0, 0x0, 0x6f, 0xa0, + 0x5, 0xfb, 0x0, 0x0, 0x7f, 0x80, 0x1, 0xff, + 0x81, 0x5, 0xff, 0x20, 0x0, 0x5f, 0xff, 0xff, + 0xc2, 0x0, 0x0, 0x2a, 0xfb, 0xbe, 0xf9, 0x0, + 0x2, 0xed, 0x20, 0x1, 0xbf, 0x90, 0xb, 0xf4, + 0x0, 0x0, 0x1f, 0xf1, 0xf, 0xf0, 0x0, 0x0, + 0xc, 0xf3, 0xf, 0xf0, 0x0, 0x0, 0xc, 0xf4, + 0xe, 0xf4, 0x0, 0x0, 0x1f, 0xf1, 0x7, 0xfd, + 0x20, 0x1, 0xbf, 0xa0, 0x0, 0xbf, 0xfc, 0xbe, + 0xfd, 0x10, 0x0, 0x6, 0xcf, 0xfd, 0x70, 0x0, + + /* U+0039 "9" */ + 0x0, 0x6, 0xcf, 0xfb, 0x40, 0x0, 0x0, 0xbf, + 0xfb, 0xbe, 0xf7, 0x0, 0x6, 0xfe, 0x20, 0x1, + 0xcf, 0x40, 0xd, 0xf5, 0x0, 0x0, 0x2f, 0xb0, + 0xf, 0xf0, 0x0, 0x0, 0xe, 0xf0, 0xf, 0xf0, + 0x0, 0x0, 0xe, 0xf2, 0xd, 0xf4, 0x0, 0x0, + 0x3f, 0xf4, 0x7, 0xfe, 0x30, 0x2, 0xdf, 0xf4, + 0x0, 0xcf, 0xfd, 0xdf, 0xdb, 0xf4, 0x0, 0x7, + 0xdf, 0xe8, 0xb, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xf1, 0x2, 0x40, 0x0, 0x0, 0x2f, 0xe0, + 0x9, 0xf5, 0x0, 0x0, 0x8f, 0x90, 0x4, 0xfd, + 0x0, 0x4, 0xff, 0x10, 0x0, 0xaf, 0xeb, 0xcf, + 0xf5, 0x0, 0x0, 0x7, 0xdf, 0xea, 0x20, 0x0, + + /* U+003A ":" */ + 0xf, 0xf2, 0xf, 0xf2, 0x4, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0x40, 0xf, 0xf2, 0xf, 0xf2, + + /* U+003B ";" */ + 0x1f, 0xf1, 0x1f, 0xf1, 0x4, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0x40, 0x1f, 0xf1, 0x1f, 0xf1, + 0x0, 0xf0, 0x5, 0xd0, 0xe, 0x40, 0x0, 0x0, + + /* U+003C "<" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x30, 0x0, 0x0, + 0x0, 0x18, 0xea, 0x0, 0x0, 0x3, 0xaf, 0xff, + 0x60, 0x0, 0x5c, 0xff, 0xd6, 0x0, 0x17, 0xef, + 0xfa, 0x40, 0x0, 0xc, 0xfe, 0x81, 0x0, 0x0, + 0x0, 0xcf, 0xe8, 0x10, 0x0, 0x0, 0x1, 0x7e, + 0xff, 0xa3, 0x0, 0x0, 0x0, 0x5, 0xcf, 0xfc, + 0x60, 0x0, 0x0, 0x0, 0x3a, 0xff, 0xe6, 0x0, + 0x0, 0x0, 0x2, 0x9f, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x3, + + /* U+003D "=" */ + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xaa, 0xdd, 0xdd, + 0xdd, 0xdd, 0xd8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0xad, 0xdd, 0xdd, 0xdd, 0xdd, 0x80, + + /* U+003E ">" */ + 0x30, 0x0, 0x0, 0x0, 0x0, 0xc, 0xe7, 0x10, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0x92, 0x0, 0x0, + 0x0, 0x17, 0xef, 0xfb, 0x40, 0x0, 0x0, 0x0, + 0x5b, 0xff, 0xd6, 0x0, 0x0, 0x0, 0x2, 0x9f, + 0xfa, 0x0, 0x0, 0x0, 0x29, 0xff, 0xa0, 0x0, + 0x4, 0xbf, 0xfd, 0x60, 0x1, 0x7d, 0xff, 0xb4, + 0x0, 0x7, 0xff, 0xf9, 0x20, 0x0, 0x0, 0xce, + 0x81, 0x0, 0x0, 0x0, 0x4, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+003F "?" */ + 0x0, 0x6c, 0xff, 0xd8, 0x0, 0x0, 0xaf, 0xfc, + 0xbe, 0xfd, 0x10, 0x6f, 0xe2, 0x0, 0x1b, 0xfb, + 0xc, 0xf6, 0x0, 0x0, 0x1f, 0xf1, 0x9b, 0x10, + 0x0, 0x0, 0xdf, 0x20, 0x0, 0x0, 0x0, 0x2f, + 0xe0, 0x0, 0x0, 0x0, 0x1d, 0xf7, 0x0, 0x0, + 0x0, 0x1d, 0xf9, 0x0, 0x0, 0x0, 0xd, 0xf8, + 0x0, 0x0, 0x0, 0x8, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0x20, 0x0, 0x0, 0x0, 0xe, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x11, 0x0, 0x0, 0x0, + 0x0, 0x4, 0x40, 0x0, 0x0, 0x0, 0x0, 0xff, + 0x30, 0x0, 0x0, 0x0, 0xf, 0xf3, 0x0, 0x0, + + /* U+0040 "@" */ + 0x0, 0x0, 0x0, 0x38, 0xce, 0xff, 0xda, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xbf, 0xfe, 0xba, + 0xac, 0xff, 0xe6, 0x0, 0x0, 0x0, 0x4, 0xff, + 0x92, 0x0, 0x0, 0x0, 0x6e, 0xf8, 0x0, 0x0, + 0x3, 0xfe, 0x30, 0x0, 0x0, 0x0, 0x0, 0x1b, + 0xf6, 0x0, 0x0, 0xde, 0x20, 0x3, 0xbf, 0xe9, + 0x9, 0xf5, 0xc, 0xf1, 0x0, 0x7f, 0x40, 0x5, + 0xff, 0xbb, 0xfb, 0xcf, 0x20, 0x3f, 0x80, 0xe, + 0xb0, 0x2, 0xfe, 0x30, 0x3, 0xff, 0xf0, 0x0, + 0xcd, 0x4, 0xf5, 0x0, 0xcf, 0x50, 0x0, 0xa, + 0xfb, 0x0, 0x9, 0xf0, 0x8f, 0x0, 0x3f, 0xd0, + 0x0, 0x0, 0x7f, 0x80, 0x0, 0x9f, 0xa, 0xe0, + 0x7, 0xf8, 0x0, 0x0, 0x8, 0xf5, 0x0, 0xa, + 0xf0, 0xbd, 0x0, 0x9f, 0x50, 0x0, 0x0, 0xbf, + 0x20, 0x0, 0xeb, 0xa, 0xe0, 0xa, 0xf6, 0x0, + 0x0, 0x1f, 0xe0, 0x0, 0x6f, 0x60, 0x9f, 0x10, + 0x7f, 0x90, 0x0, 0xb, 0xfb, 0x0, 0x2f, 0xd0, + 0x5, 0xf5, 0x2, 0xff, 0x40, 0x9, 0xff, 0xa0, + 0x4e, 0xf2, 0x0, 0xf, 0xd0, 0x9, 0xff, 0xef, + 0xfa, 0xff, 0xef, 0xe3, 0x0, 0x0, 0x7f, 0x80, + 0x7, 0xef, 0xb2, 0x1c, 0xfe, 0x91, 0x1, 0x31, + 0x0, 0xcf, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xee, 0x20, 0x1, 0xcf, 0xd7, 0x20, 0x0, + 0x0, 0x0, 0x4b, 0xfd, 0x20, 0x0, 0x0, 0x7e, + 0xff, 0xec, 0xba, 0xbd, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x5, 0x9c, 0xef, 0xfe, 0xda, 0x61, + 0x0, 0x0, + + /* U+0041 "A" */ + 0x0, 0x0, 0x0, 0x2f, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xed, 0xaf, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xf9, 0x4f, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xf4, 0xe, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xe0, 0x8, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0x90, 0x2, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0x30, 0x0, 0xcf, 0x40, 0x0, + 0x0, 0x2, 0xfd, 0x0, 0x0, 0x6f, 0xb0, 0x0, + 0x0, 0x8, 0xfe, 0xcc, 0xcc, 0xcf, 0xf1, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x5f, 0xc0, 0x0, 0x0, 0x4, 0xfe, 0x0, + 0x0, 0xbf, 0x60, 0x0, 0x0, 0x0, 0xef, 0x50, + 0x1, 0xff, 0x10, 0x0, 0x0, 0x0, 0x9f, 0xb0, + 0x7, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf2, + 0xd, 0xf6, 0x0, 0x0, 0x0, 0x0, 0xd, 0xf8, + + /* U+0042 "B" */ + 0x6f, 0xff, 0xff, 0xfe, 0xc6, 0x0, 0x6, 0xff, + 0xee, 0xee, 0xff, 0xfa, 0x0, 0x6f, 0xb0, 0x0, + 0x0, 0x5f, 0xf5, 0x6, 0xfb, 0x0, 0x0, 0x0, + 0x7f, 0xa0, 0x6f, 0xb0, 0x0, 0x0, 0x5, 0xfb, + 0x6, 0xfb, 0x0, 0x0, 0x0, 0x8f, 0x80, 0x6f, + 0xb0, 0x0, 0x1, 0x6f, 0xe1, 0x6, 0xff, 0xff, + 0xff, 0xff, 0xe2, 0x0, 0x6f, 0xfe, 0xee, 0xef, + 0xff, 0xd2, 0x6, 0xfb, 0x0, 0x0, 0x2, 0xaf, + 0xd0, 0x6f, 0xb0, 0x0, 0x0, 0x0, 0xdf, 0x56, + 0xfb, 0x0, 0x0, 0x0, 0xb, 0xf7, 0x6f, 0xb0, + 0x0, 0x0, 0x0, 0xdf, 0x66, 0xfb, 0x0, 0x0, + 0x2, 0xaf, 0xf1, 0x6f, 0xfe, 0xee, 0xef, 0xff, + 0xf5, 0x6, 0xff, 0xff, 0xff, 0xfd, 0x93, 0x0, + + /* U+0043 "C" */ + 0x0, 0x0, 0x6b, 0xef, 0xeb, 0x60, 0x0, 0x0, + 0x3, 0xdf, 0xfe, 0xdf, 0xff, 0xc1, 0x0, 0x2, + 0xff, 0xb3, 0x0, 0x4, 0xdf, 0xc0, 0x0, 0xdf, + 0xa0, 0x0, 0x0, 0x2, 0xef, 0x50, 0x4f, 0xe0, + 0x0, 0x0, 0x0, 0x8, 0xd7, 0x9, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0x90, 0x0, 0x0, 0x0, + 0x1, 0x95, 0x3, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xd0, 0xc, 0xf9, 0x0, 0x0, 0x0, 0x2f, + 0xf6, 0x0, 0x2f, 0xfb, 0x20, 0x0, 0x5e, 0xfc, + 0x0, 0x0, 0x4e, 0xff, 0xee, 0xff, 0xfc, 0x10, + 0x0, 0x0, 0x17, 0xce, 0xfe, 0xb5, 0x0, 0x0, + + /* U+0044 "D" */ + 0x4f, 0xff, 0xff, 0xff, 0xd9, 0x20, 0x0, 0x4f, + 0xfe, 0xee, 0xef, 0xff, 0xf5, 0x0, 0x4f, 0xd0, + 0x0, 0x0, 0x3a, 0xff, 0x40, 0x4f, 0xd0, 0x0, + 0x0, 0x0, 0x9f, 0xd0, 0x4f, 0xd0, 0x0, 0x0, + 0x0, 0x1f, 0xf3, 0x4f, 0xd0, 0x0, 0x0, 0x0, + 0xb, 0xf7, 0x4f, 0xd0, 0x0, 0x0, 0x0, 0x8, + 0xfa, 0x4f, 0xd0, 0x0, 0x0, 0x0, 0x7, 0xfb, + 0x4f, 0xd0, 0x0, 0x0, 0x0, 0x7, 0xfb, 0x4f, + 0xd0, 0x0, 0x0, 0x0, 0x8, 0xfa, 0x4f, 0xd0, + 0x0, 0x0, 0x0, 0xb, 0xf7, 0x4f, 0xd0, 0x0, + 0x0, 0x0, 0x1f, 0xf3, 0x4f, 0xd0, 0x0, 0x0, + 0x0, 0xaf, 0xc0, 0x4f, 0xd0, 0x0, 0x0, 0x3a, + 0xff, 0x30, 0x4f, 0xfe, 0xee, 0xef, 0xff, 0xf5, + 0x0, 0x4f, 0xff, 0xff, 0xfe, 0xc8, 0x20, 0x0, + + /* U+0045 "E" */ + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x24, 0xff, + 0xee, 0xee, 0xee, 0xee, 0xe1, 0x4f, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x80, 0x4f, 0xfe, 0xee, 0xee, + 0xee, 0xe7, 0x4, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xfe, 0xee, 0xee, 0xee, + 0xee, 0x74, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + + /* U+0046 "F" */ + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x3f, 0xfe, + 0xee, 0xee, 0xee, 0xe5, 0x3f, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0x30, + 0x3f, 0xfe, 0xee, 0xee, 0xee, 0x30, 0x3f, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xd0, 0x0, 0x0, 0x0, 0x0, + + /* U+0047 "G" */ + 0x0, 0x0, 0x5a, 0xdf, 0xfe, 0xa5, 0x0, 0x0, + 0x1, 0xcf, 0xff, 0xde, 0xff, 0xfb, 0x0, 0x1, + 0xef, 0xd4, 0x0, 0x0, 0x5e, 0xfa, 0x0, 0xaf, + 0xc0, 0x0, 0x0, 0x0, 0x1e, 0xf2, 0x2f, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x68, 0x28, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xf4, 0x0, 0x0, + 0xe, 0xee, 0xee, 0xea, 0xdf, 0x50, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xbb, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xfb, 0x8f, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xb3, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x5, 0xfb, 0xb, 0xfd, 0x10, 0x0, 0x0, 0x0, + 0xaf, 0xb0, 0x1d, 0xfe, 0x71, 0x0, 0x27, 0xef, + 0xf7, 0x0, 0x1b, 0xff, 0xff, 0xff, 0xff, 0xd4, + 0x0, 0x0, 0x4, 0xad, 0xff, 0xea, 0x50, 0x0, + + /* U+0048 "H" */ + 0x3f, 0xd0, 0x0, 0x0, 0x0, 0xf, 0xf1, 0x3f, + 0xd0, 0x0, 0x0, 0x0, 0xf, 0xf1, 0x3f, 0xd0, + 0x0, 0x0, 0x0, 0xf, 0xf1, 0x3f, 0xd0, 0x0, + 0x0, 0x0, 0xf, 0xf1, 0x3f, 0xd0, 0x0, 0x0, + 0x0, 0xf, 0xf1, 0x3f, 0xd0, 0x0, 0x0, 0x0, + 0xf, 0xf1, 0x3f, 0xfe, 0xee, 0xee, 0xee, 0xef, + 0xf1, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0x3f, 0xd0, 0x0, 0x0, 0x0, 0xf, 0xf1, 0x3f, + 0xd0, 0x0, 0x0, 0x0, 0xf, 0xf1, 0x3f, 0xd0, + 0x0, 0x0, 0x0, 0xf, 0xf1, 0x3f, 0xd0, 0x0, + 0x0, 0x0, 0xf, 0xf1, 0x3f, 0xd0, 0x0, 0x0, + 0x0, 0xf, 0xf1, 0x3f, 0xd0, 0x0, 0x0, 0x0, + 0xf, 0xf1, 0x3f, 0xd0, 0x0, 0x0, 0x0, 0xf, + 0xf1, 0x3f, 0xd0, 0x0, 0x0, 0x0, 0xf, 0xf1, + + /* U+0049 "I" */ + 0xff, 0x1f, 0xf1, 0xff, 0x1f, 0xf1, 0xff, 0x1f, + 0xf1, 0xff, 0x1f, 0xf1, 0xff, 0x1f, 0xf1, 0xff, + 0x1f, 0xf1, 0xff, 0x1f, 0xf1, 0xff, 0x1f, 0xf1, + + /* U+004A "J" */ + 0x0, 0x0, 0x0, 0xc, 0xf4, 0x0, 0x0, 0x0, + 0xc, 0xf4, 0x0, 0x0, 0x0, 0xc, 0xf4, 0x0, + 0x0, 0x0, 0xc, 0xf4, 0x0, 0x0, 0x0, 0xc, + 0xf4, 0x0, 0x0, 0x0, 0xc, 0xf4, 0x0, 0x0, + 0x0, 0xc, 0xf4, 0x0, 0x0, 0x0, 0xc, 0xf4, + 0x0, 0x0, 0x0, 0xc, 0xf4, 0x0, 0x0, 0x0, + 0xc, 0xf4, 0x0, 0x0, 0x0, 0xc, 0xf4, 0x4e, + 0x90, 0x0, 0xd, 0xf4, 0x4f, 0xc0, 0x0, 0xf, + 0xf2, 0x1f, 0xf6, 0x0, 0x9f, 0xe0, 0x8, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x6d, 0xff, 0xb4, 0x0, + + /* U+004B "K" */ + 0x6f, 0xb0, 0x0, 0x0, 0x1, 0xdf, 0xc1, 0x6f, + 0xb0, 0x0, 0x0, 0x1d, 0xfc, 0x0, 0x6f, 0xb0, + 0x0, 0x1, 0xdf, 0xc0, 0x0, 0x6f, 0xb0, 0x0, + 0x1d, 0xfb, 0x0, 0x0, 0x6f, 0xb0, 0x1, 0xdf, + 0xb0, 0x0, 0x0, 0x6f, 0xb0, 0x1d, 0xfb, 0x0, + 0x0, 0x0, 0x6f, 0xb1, 0xcf, 0xe0, 0x0, 0x0, + 0x0, 0x6f, 0xcc, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xa5, 0xff, 0x30, 0x0, 0x0, 0x6f, + 0xfa, 0x0, 0x9f, 0xd0, 0x0, 0x0, 0x6f, 0xc0, + 0x0, 0xd, 0xfa, 0x0, 0x0, 0x6f, 0xb0, 0x0, + 0x3, 0xff, 0x60, 0x0, 0x6f, 0xb0, 0x0, 0x0, + 0x8f, 0xf2, 0x0, 0x6f, 0xb0, 0x0, 0x0, 0xd, + 0xfc, 0x0, 0x6f, 0xb0, 0x0, 0x0, 0x2, 0xff, + 0x80, 0x6f, 0xb0, 0x0, 0x0, 0x0, 0x7f, 0xf4, + + /* U+004C "L" */ + 0x5f, 0xb0, 0x0, 0x0, 0x0, 0x5, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xb0, 0x0, 0x0, 0x0, + 0x5, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xb0, + 0x0, 0x0, 0x0, 0x5, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xb0, 0x0, 0x0, 0x0, 0x5, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xb0, 0x0, 0x0, + 0x0, 0x5, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xb0, 0x0, 0x0, 0x0, 0x5, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xb0, 0x0, 0x0, 0x0, 0x5, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfe, 0xee, + 0xee, 0xee, 0x75, 0xff, 0xff, 0xff, 0xff, 0xf8, + + /* U+004D "M" */ + 0x5f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xfb, + 0x5f, 0xff, 0x40, 0x0, 0x0, 0x0, 0xaf, 0xfb, + 0x5f, 0xef, 0x90, 0x0, 0x0, 0x0, 0xff, 0xfb, + 0x5f, 0xaf, 0xe0, 0x0, 0x0, 0x4, 0xfb, 0xfb, + 0x5f, 0xaa, 0xf4, 0x0, 0x0, 0xa, 0xf6, 0xfb, + 0x5f, 0xa4, 0xf9, 0x0, 0x0, 0xf, 0xa5, 0xfb, + 0x5f, 0xa0, 0xfe, 0x0, 0x0, 0x5f, 0x55, 0xfb, + 0x5f, 0xa0, 0xaf, 0x40, 0x0, 0xaf, 0x5, 0xfb, + 0x5f, 0xa0, 0x4f, 0x90, 0x0, 0xfa, 0x5, 0xfb, + 0x5f, 0xa0, 0xe, 0xe0, 0x5, 0xf5, 0x5, 0xfb, + 0x5f, 0xa0, 0xa, 0xf3, 0xa, 0xf0, 0x5, 0xfb, + 0x5f, 0xa0, 0x4, 0xf9, 0xf, 0xa0, 0x5, 0xfb, + 0x5f, 0xa0, 0x0, 0xee, 0x5f, 0x40, 0x5, 0xfb, + 0x5f, 0xa0, 0x0, 0x9f, 0xde, 0x0, 0x5, 0xfb, + 0x5f, 0xa0, 0x0, 0x4f, 0xf9, 0x0, 0x5, 0xfb, + 0x5f, 0xa0, 0x0, 0xe, 0xf4, 0x0, 0x5, 0xfb, + + /* U+004E "N" */ + 0x4f, 0xf3, 0x0, 0x0, 0x0, 0xd, 0xf2, 0x4f, + 0xfd, 0x0, 0x0, 0x0, 0xd, 0xf2, 0x4f, 0xff, + 0x80, 0x0, 0x0, 0xd, 0xf2, 0x4f, 0xef, 0xf3, + 0x0, 0x0, 0xd, 0xf2, 0x4f, 0xb8, 0xfd, 0x0, + 0x0, 0xd, 0xf2, 0x4f, 0xb0, 0xdf, 0x70, 0x0, + 0xd, 0xf2, 0x4f, 0xb0, 0x3f, 0xf2, 0x0, 0xd, + 0xf2, 0x4f, 0xb0, 0x9, 0xfc, 0x0, 0xd, 0xf2, + 0x4f, 0xb0, 0x0, 0xdf, 0x70, 0xd, 0xf2, 0x4f, + 0xb0, 0x0, 0x4f, 0xf2, 0xd, 0xf2, 0x4f, 0xb0, + 0x0, 0x9, 0xfc, 0xd, 0xf2, 0x4f, 0xb0, 0x0, + 0x0, 0xef, 0x7d, 0xf2, 0x4f, 0xb0, 0x0, 0x0, + 0x4f, 0xfe, 0xf2, 0x4f, 0xb0, 0x0, 0x0, 0xa, + 0xff, 0xf2, 0x4f, 0xb0, 0x0, 0x0, 0x1, 0xef, + 0xf2, 0x4f, 0xb0, 0x0, 0x0, 0x0, 0x5f, 0xf2, + + /* U+004F "O" */ + 0x0, 0x0, 0x6b, 0xef, 0xec, 0x70, 0x0, 0x0, + 0x0, 0x2d, 0xff, 0xfd, 0xff, 0xfe, 0x30, 0x0, + 0x2, 0xff, 0xc3, 0x0, 0x3, 0xbf, 0xf3, 0x0, + 0xd, 0xfa, 0x0, 0x0, 0x0, 0x9, 0xfe, 0x0, + 0x4f, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0x60, + 0x9f, 0x80, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xc0, + 0xdf, 0x50, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf0, + 0xef, 0x30, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf0, + 0xef, 0x30, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf0, + 0xdf, 0x40, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf0, + 0x9f, 0x80, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xc0, + 0x4f, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0x60, + 0xc, 0xfa, 0x0, 0x0, 0x0, 0x9, 0xfe, 0x0, + 0x2, 0xef, 0xc3, 0x0, 0x3, 0xbf, 0xf3, 0x0, + 0x0, 0x2d, 0xff, 0xfd, 0xef, 0xfe, 0x30, 0x0, + 0x0, 0x0, 0x6b, 0xef, 0xec, 0x70, 0x0, 0x0, + + /* U+0050 "P" */ + 0x4f, 0xff, 0xff, 0xff, 0xeb, 0x50, 0x4, 0xff, + 0xee, 0xee, 0xef, 0xff, 0xa0, 0x4f, 0xc0, 0x0, + 0x0, 0x6, 0xff, 0x44, 0xfc, 0x0, 0x0, 0x0, + 0xa, 0xf9, 0x4f, 0xc0, 0x0, 0x0, 0x0, 0x7f, + 0xb4, 0xfc, 0x0, 0x0, 0x0, 0xb, 0xf9, 0x4f, + 0xc0, 0x0, 0x0, 0x29, 0xff, 0x34, 0xff, 0xee, + 0xee, 0xff, 0xff, 0x80, 0x4f, 0xff, 0xff, 0xff, + 0xea, 0x40, 0x4, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0051 "Q" */ + 0x0, 0x0, 0x6b, 0xef, 0xec, 0x70, 0x0, 0x0, + 0x0, 0x2d, 0xff, 0xfd, 0xef, 0xfe, 0x30, 0x0, + 0x2, 0xef, 0xc3, 0x0, 0x2, 0xaf, 0xf3, 0x0, + 0xc, 0xfa, 0x0, 0x0, 0x0, 0x8, 0xfd, 0x0, + 0x4f, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0x60, + 0xaf, 0x80, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xb0, + 0xdf, 0x50, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf0, + 0xef, 0x30, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf0, + 0xef, 0x30, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf0, + 0xdf, 0x50, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf0, + 0x9f, 0x80, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xc0, + 0x4f, 0xe0, 0x0, 0x0, 0x82, 0x0, 0xdf, 0x60, + 0xc, 0xfa, 0x0, 0x3, 0xff, 0x89, 0xfe, 0x0, + 0x2, 0xef, 0xc3, 0x0, 0x2c, 0xff, 0xf3, 0x0, + 0x0, 0x2d, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x6b, 0xef, 0xeb, 0x62, 0xcf, 0xe2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xc0, + + /* U+0052 "R" */ + 0x3f, 0xff, 0xff, 0xff, 0xfe, 0xa3, 0x0, 0x3, + 0xff, 0xcc, 0xcc, 0xcd, 0xff, 0xf5, 0x0, 0x3f, + 0xd0, 0x0, 0x0, 0x0, 0xaf, 0xe0, 0x3, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0xff, 0x30, 0x3f, 0xd0, + 0x0, 0x0, 0x0, 0xd, 0xf5, 0x3, 0xfd, 0x0, + 0x0, 0x0, 0x2, 0xff, 0x30, 0x3f, 0xd0, 0x0, + 0x0, 0x15, 0xdf, 0xc0, 0x3, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xc1, 0x0, 0x3f, 0xfd, 0xde, 0xff, + 0xfa, 0x40, 0x0, 0x3, 0xfd, 0x0, 0x0, 0x8f, + 0xe3, 0x0, 0x0, 0x3f, 0xd0, 0x0, 0x0, 0x8f, + 0xe2, 0x0, 0x3, 0xfd, 0x0, 0x0, 0x0, 0xcf, + 0xc0, 0x0, 0x3f, 0xd0, 0x0, 0x0, 0x2, 0xff, + 0x70, 0x3, 0xfd, 0x0, 0x0, 0x0, 0x8, 0xff, + 0x10, 0x3f, 0xd0, 0x0, 0x0, 0x0, 0xd, 0xfb, + 0x3, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf5, + + /* U+0053 "S" */ + 0x0, 0x1, 0x8d, 0xff, 0xea, 0x40, 0x0, 0x0, + 0x4f, 0xff, 0xfe, 0xff, 0xf9, 0x0, 0x0, 0xef, + 0x92, 0x0, 0x6, 0xff, 0x60, 0x4, 0xfc, 0x0, + 0x0, 0x0, 0x5f, 0xd0, 0x5, 0xfa, 0x0, 0x0, + 0x0, 0xc, 0xb0, 0x2, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xfd, 0x84, 0x10, 0x0, + 0x0, 0x0, 0x6, 0xdf, 0xff, 0xfc, 0x71, 0x0, + 0x0, 0x0, 0x2, 0x7b, 0xef, 0xfe, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xbf, 0xe1, 0x4, 0x60, + 0x0, 0x0, 0x0, 0xc, 0xf6, 0xe, 0xf2, 0x0, + 0x0, 0x0, 0x8, 0xf7, 0xa, 0xfa, 0x0, 0x0, + 0x0, 0xc, 0xf5, 0x2, 0xff, 0xc5, 0x0, 0x3, + 0xbf, 0xe0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xfe, + 0x30, 0x0, 0x1, 0x8c, 0xef, 0xfc, 0x81, 0x0, + + /* U+0054 "T" */ + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xee, + 0xee, 0xff, 0xfe, 0xee, 0xed, 0x0, 0x0, 0x5, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xc0, 0x0, 0x0, + + /* U+0055 "U" */ + 0x4f, 0xd0, 0x0, 0x0, 0x0, 0xf, 0xf2, 0x4f, + 0xd0, 0x0, 0x0, 0x0, 0xf, 0xf2, 0x4f, 0xd0, + 0x0, 0x0, 0x0, 0xf, 0xf2, 0x4f, 0xd0, 0x0, + 0x0, 0x0, 0xf, 0xf2, 0x4f, 0xd0, 0x0, 0x0, + 0x0, 0xf, 0xf2, 0x4f, 0xd0, 0x0, 0x0, 0x0, + 0xf, 0xf2, 0x4f, 0xd0, 0x0, 0x0, 0x0, 0xf, + 0xf2, 0x4f, 0xd0, 0x0, 0x0, 0x0, 0xf, 0xf2, + 0x4f, 0xd0, 0x0, 0x0, 0x0, 0xf, 0xf2, 0x3f, + 0xd0, 0x0, 0x0, 0x0, 0xf, 0xf1, 0x2f, 0xe0, + 0x0, 0x0, 0x0, 0xf, 0xf0, 0xf, 0xf1, 0x0, + 0x0, 0x0, 0x3f, 0xe0, 0xc, 0xf7, 0x0, 0x0, + 0x0, 0x9f, 0xb0, 0x5, 0xff, 0x81, 0x0, 0x28, + 0xff, 0x30, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x4, 0xae, 0xff, 0xd9, 0x20, 0x0, + + /* U+0056 "V" */ + 0xbf, 0x80, 0x0, 0x0, 0x0, 0x0, 0xcf, 0x55, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xe0, 0xe, + 0xf3, 0x0, 0x0, 0x0, 0x8, 0xf8, 0x0, 0x8f, + 0x90, 0x0, 0x0, 0x0, 0xef, 0x20, 0x2, 0xfe, + 0x0, 0x0, 0x0, 0x4f, 0xc0, 0x0, 0xc, 0xf4, + 0x0, 0x0, 0xa, 0xf6, 0x0, 0x0, 0x6f, 0xa0, + 0x0, 0x0, 0xff, 0x0, 0x0, 0x1, 0xff, 0x0, + 0x0, 0x5f, 0x90, 0x0, 0x0, 0xa, 0xf5, 0x0, + 0xb, 0xf3, 0x0, 0x0, 0x0, 0x4f, 0xb0, 0x1, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0xef, 0x10, 0x7f, + 0x70, 0x0, 0x0, 0x0, 0x8, 0xf6, 0xd, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xb2, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0x8f, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xf8, 0x0, 0x0, 0x0, + + /* U+0057 "W" */ + 0xaf, 0x70, 0x0, 0x0, 0xf, 0xfc, 0x0, 0x0, + 0x0, 0xbf, 0x56, 0xfb, 0x0, 0x0, 0x4, 0xff, + 0xf1, 0x0, 0x0, 0xf, 0xf1, 0x2f, 0xe0, 0x0, + 0x0, 0x9f, 0xbf, 0x50, 0x0, 0x3, 0xfc, 0x0, + 0xdf, 0x20, 0x0, 0xd, 0xf4, 0xf9, 0x0, 0x0, + 0x7f, 0x80, 0x9, 0xf6, 0x0, 0x1, 0xfa, 0xf, + 0xe0, 0x0, 0xb, 0xf4, 0x0, 0x5f, 0x90, 0x0, + 0x6f, 0x60, 0xbf, 0x20, 0x0, 0xef, 0x0, 0x1, + 0xfd, 0x0, 0xa, 0xf2, 0x7, 0xf7, 0x0, 0x2f, + 0xb0, 0x0, 0xd, 0xf1, 0x0, 0xed, 0x0, 0x2f, + 0xb0, 0x6, 0xf7, 0x0, 0x0, 0x8f, 0x40, 0x3f, + 0x90, 0x0, 0xef, 0x0, 0xaf, 0x20, 0x0, 0x4, + 0xf8, 0x7, 0xf5, 0x0, 0xa, 0xf3, 0xe, 0xe0, + 0x0, 0x0, 0xf, 0xc0, 0xcf, 0x0, 0x0, 0x5f, + 0x72, 0xfa, 0x0, 0x0, 0x0, 0xcf, 0x1f, 0xc0, + 0x0, 0x1, 0xfb, 0x6f, 0x50, 0x0, 0x0, 0x8, + 0xf7, 0xf7, 0x0, 0x0, 0xd, 0xe9, 0xf1, 0x0, + 0x0, 0x0, 0x4f, 0xdf, 0x30, 0x0, 0x0, 0x8f, + 0xed, 0x0, 0x0, 0x0, 0x0, 0xff, 0xe0, 0x0, + 0x0, 0x4, 0xff, 0x80, 0x0, 0x0, 0x0, 0xb, + 0xfa, 0x0, 0x0, 0x0, 0xf, 0xf4, 0x0, 0x0, + + /* U+0058 "X" */ + 0xd, 0xfa, 0x0, 0x0, 0x0, 0x8, 0xfb, 0x0, + 0x2f, 0xf5, 0x0, 0x0, 0x4, 0xfe, 0x10, 0x0, + 0x6f, 0xe1, 0x0, 0x1, 0xef, 0x40, 0x0, 0x0, + 0xbf, 0xb0, 0x0, 0xcf, 0x80, 0x0, 0x0, 0x1, + 0xef, 0x60, 0x8f, 0xc0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0x5f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xaf, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0xdf, 0x70, 0xdf, + 0xa0, 0x0, 0x0, 0x0, 0x9f, 0xc0, 0x2, 0xff, + 0x50, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x7, 0xff, + 0x10, 0x0, 0x2f, 0xf5, 0x0, 0x0, 0xc, 0xfc, + 0x0, 0xc, 0xfa, 0x0, 0x0, 0x0, 0x2f, 0xf7, + 0x8, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x6f, 0xf3, + + /* U+0059 "Y" */ + 0x9f, 0xd0, 0x0, 0x0, 0x0, 0x4, 0xff, 0x20, + 0xef, 0x80, 0x0, 0x0, 0x0, 0xdf, 0x70, 0x4, + 0xff, 0x30, 0x0, 0x0, 0x8f, 0xc0, 0x0, 0xa, + 0xfd, 0x0, 0x0, 0x3f, 0xf2, 0x0, 0x0, 0x1e, + 0xf7, 0x0, 0xd, 0xf6, 0x0, 0x0, 0x0, 0x5f, + 0xf2, 0x7, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xb1, 0xff, 0x10, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xdf, 0x60, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xf3, 0x0, 0x0, 0x0, + + /* U+005A "Z" */ + 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x9e, + 0xee, 0xee, 0xee, 0xef, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0x20, 0x0, 0x0, 0x0, 0x4, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x2, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xd1, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x6, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x3, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xfe, 0xee, 0xee, 0xee, + 0xee, 0xc9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + + /* U+005B "[" */ + 0x8f, 0xff, 0xb8, 0xfc, 0xa7, 0x8f, 0x60, 0x8, + 0xf6, 0x0, 0x8f, 0x60, 0x8, 0xf6, 0x0, 0x8f, + 0x60, 0x8, 0xf6, 0x0, 0x8f, 0x60, 0x8, 0xf6, + 0x0, 0x8f, 0x60, 0x8, 0xf6, 0x0, 0x8f, 0x60, + 0x8, 0xf6, 0x0, 0x8f, 0x60, 0x8, 0xf6, 0x0, + 0x8f, 0x60, 0x8, 0xf6, 0x0, 0x8f, 0xca, 0x78, + 0xff, 0xfb, + + /* U+005C "\\" */ + 0xdb, 0x0, 0x0, 0x9, 0xf0, 0x0, 0x0, 0x4f, + 0x40, 0x0, 0x0, 0xf8, 0x0, 0x0, 0xb, 0xd0, + 0x0, 0x0, 0x6f, 0x20, 0x0, 0x2, 0xf6, 0x0, + 0x0, 0xd, 0xb0, 0x0, 0x0, 0x9f, 0x0, 0x0, + 0x4, 0xf4, 0x0, 0x0, 0xf, 0x80, 0x0, 0x0, + 0xbd, 0x0, 0x0, 0x7, 0xf1, 0x0, 0x0, 0x2f, + 0x60, 0x0, 0x0, 0xda, 0x0, 0x0, 0x9, 0xf0, + + /* U+005D "]" */ + 0x9f, 0xff, 0xa6, 0xab, 0xfa, 0x0, 0x4f, 0xa0, + 0x4, 0xfa, 0x0, 0x4f, 0xa0, 0x4, 0xfa, 0x0, + 0x4f, 0xa0, 0x4, 0xfa, 0x0, 0x4f, 0xa0, 0x4, + 0xfa, 0x0, 0x4f, 0xa0, 0x4, 0xfa, 0x0, 0x4f, + 0xa0, 0x4, 0xfa, 0x0, 0x4f, 0xa0, 0x4, 0xfa, + 0x0, 0x4f, 0xa0, 0x4, 0xfa, 0x6a, 0xcf, 0xa9, + 0xff, 0xfa, + + /* U+005E "^" */ + 0x0, 0x0, 0xdf, 0x20, 0x0, 0x0, 0x4, 0xff, + 0x90, 0x0, 0x0, 0xa, 0xfd, 0xf0, 0x0, 0x0, + 0x1f, 0xa6, 0xf6, 0x0, 0x0, 0x8f, 0x40, 0xfd, + 0x0, 0x0, 0xee, 0x0, 0x9f, 0x40, 0x5, 0xf8, + 0x0, 0x3f, 0xb0, 0xc, 0xf2, 0x0, 0xc, 0xf1, + 0x3f, 0xc0, 0x0, 0x6, 0xf8, + + /* U+005F "_" */ + 0x2, 0x22, 0x22, 0x22, 0x22, 0x22, 0x20, 0x2f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x5, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x51, + + /* U+0060 "`" */ + 0x1, 0x10, 0x0, 0x9f, 0xd0, 0x0, 0xcf, 0x40, + 0x1, 0xec, + + /* U+0061 "a" */ + 0x0, 0x7, 0xce, 0xfe, 0xa3, 0x0, 0x0, 0xcf, + 0xeb, 0xbe, 0xff, 0x20, 0x7, 0xfb, 0x0, 0x0, + 0xaf, 0x90, 0x7, 0xb2, 0x0, 0x0, 0x4f, 0xb0, + 0x0, 0x0, 0x0, 0x3, 0x8f, 0xb0, 0x0, 0x17, + 0xbe, 0xff, 0xff, 0xb0, 0x4, 0xff, 0xfb, 0x95, + 0x5f, 0xb0, 0xe, 0xf7, 0x0, 0x0, 0x4f, 0xb0, + 0x2f, 0xf0, 0x0, 0x0, 0x8f, 0xb0, 0xf, 0xf3, + 0x0, 0x4, 0xff, 0xc0, 0x9, 0xff, 0xa9, 0xcf, + 0xdf, 0xd0, 0x0, 0x7d, 0xff, 0xc7, 0xc, 0xf2, + + /* U+0062 "b" */ + 0x8f, 0x60, 0x0, 0x0, 0x0, 0x8, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0x60, 0x0, 0x0, 0x0, + 0x8, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x8f, 0x66, + 0xdf, 0xe8, 0x10, 0x8, 0xfd, 0xfc, 0xad, 0xfd, + 0x10, 0x8f, 0xf6, 0x0, 0xa, 0xf9, 0x8, 0xfc, + 0x0, 0x0, 0x1f, 0xf0, 0x8f, 0x70, 0x0, 0x0, + 0xcf, 0x48, 0xf4, 0x0, 0x0, 0xa, 0xf5, 0x8f, + 0x40, 0x0, 0x0, 0xaf, 0x58, 0xf5, 0x0, 0x0, + 0xc, 0xf3, 0x8f, 0xa0, 0x0, 0x2, 0xff, 0x8, + 0xff, 0x50, 0x0, 0xbf, 0x80, 0x8f, 0xcf, 0xca, + 0xef, 0xc0, 0x8, 0xf4, 0x6d, 0xfd, 0x70, 0x0, + + /* U+0063 "c" */ + 0x0, 0x5, 0xcf, 0xec, 0x50, 0x0, 0x9, 0xff, + 0xbb, 0xff, 0x90, 0x5, 0xfd, 0x20, 0x1, 0xef, + 0x30, 0xcf, 0x40, 0x0, 0x6, 0xd5, 0xf, 0xf0, + 0x0, 0x0, 0x0, 0x1, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0x0, 0x0, 0x1, 0x63, 0xc, 0xf4, 0x0, 0x0, + 0x6f, 0xa0, 0x5f, 0xd1, 0x0, 0x1e, 0xf3, 0x0, + 0xaf, 0xfb, 0xbf, 0xf8, 0x0, 0x0, 0x6c, 0xff, + 0xc5, 0x0, + + /* U+0064 "d" */ + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xb0, 0x0, 0x0, + 0x0, 0x3, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xb0, 0x0, 0x0, 0x0, 0x3, 0xfb, 0x0, 0x7, + 0xdf, 0xe8, 0x4f, 0xb0, 0xb, 0xfe, 0xbc, 0xfd, + 0xfb, 0x6, 0xfc, 0x10, 0x4, 0xff, 0xb0, 0xdf, + 0x40, 0x0, 0xa, 0xfb, 0x1f, 0xf0, 0x0, 0x0, + 0x4f, 0xb2, 0xfd, 0x0, 0x0, 0x2, 0xfb, 0x2f, + 0xd0, 0x0, 0x0, 0x1f, 0xb1, 0xff, 0x0, 0x0, + 0x3, 0xfb, 0xc, 0xf4, 0x0, 0x0, 0x7f, 0xb0, + 0x5f, 0xd1, 0x0, 0x4f, 0xfb, 0x0, 0xaf, 0xfb, + 0xcf, 0xcf, 0xb0, 0x0, 0x6d, 0xfe, 0x82, 0xfb, + + /* U+0065 "e" */ + 0x0, 0x5, 0xbf, 0xfd, 0x70, 0x0, 0x0, 0x8f, + 0xfc, 0xbe, 0xfb, 0x0, 0x4, 0xfe, 0x30, 0x0, + 0xbf, 0x70, 0xb, 0xf5, 0x0, 0x0, 0x1f, 0xe0, + 0xf, 0xf1, 0x0, 0x0, 0xc, 0xf3, 0x1f, 0xff, + 0xff, 0xff, 0xff, 0xf5, 0x2f, 0xfa, 0xaa, 0xaa, + 0xaa, 0xa3, 0xf, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xf5, 0x0, 0x0, 0xc, 0xc1, 0x5, 0xfe, + 0x30, 0x0, 0x9f, 0xc0, 0x0, 0x9f, 0xfc, 0xae, + 0xfe, 0x20, 0x0, 0x5, 0xbf, 0xfd, 0x81, 0x0, + + /* U+0066 "f" */ + 0x0, 0x3c, 0xff, 0xa0, 0xe, 0xff, 0xd8, 0x1, + 0xfe, 0x0, 0x0, 0x2f, 0xc0, 0x0, 0xdf, 0xff, + 0xff, 0x7, 0x9f, 0xe8, 0x80, 0x2, 0xfc, 0x0, + 0x0, 0x2f, 0xc0, 0x0, 0x2, 0xfc, 0x0, 0x0, + 0x2f, 0xc0, 0x0, 0x2, 0xfc, 0x0, 0x0, 0x2f, + 0xc0, 0x0, 0x2, 0xfc, 0x0, 0x0, 0x2f, 0xc0, + 0x0, 0x2, 0xfc, 0x0, 0x0, 0x2f, 0xc0, 0x0, + + /* U+0067 "g" */ + 0x0, 0x7, 0xdf, 0xe9, 0xf, 0xd0, 0xb, 0xff, + 0xbc, 0xfc, 0xfd, 0x6, 0xfc, 0x10, 0x3, 0xff, + 0xd0, 0xdf, 0x30, 0x0, 0x8, 0xfd, 0x1f, 0xe0, + 0x0, 0x0, 0x2f, 0xd3, 0xfc, 0x0, 0x0, 0x0, + 0xfd, 0x3f, 0xc0, 0x0, 0x0, 0xf, 0xd1, 0xfe, + 0x0, 0x0, 0x2, 0xfd, 0xd, 0xf2, 0x0, 0x0, + 0x7f, 0xd0, 0x6f, 0xc1, 0x0, 0x3e, 0xfc, 0x0, + 0xbf, 0xea, 0xbf, 0xdf, 0xc0, 0x0, 0x7d, 0xfe, + 0x83, 0xfb, 0x2, 0x10, 0x0, 0x0, 0x4f, 0x90, + 0xcf, 0x40, 0x0, 0x1c, 0xf4, 0x5, 0xff, 0xca, + 0xbf, 0xf9, 0x0, 0x4, 0xbe, 0xfe, 0xb5, 0x0, + + /* U+0068 "h" */ + 0x8f, 0x60, 0x0, 0x0, 0x0, 0x8f, 0x60, 0x0, + 0x0, 0x0, 0x8f, 0x60, 0x0, 0x0, 0x0, 0x8f, + 0x60, 0x0, 0x0, 0x0, 0x8f, 0x65, 0xcf, 0xfb, + 0x30, 0x8f, 0xcf, 0xec, 0xef, 0xf2, 0x8f, 0xf7, + 0x0, 0xc, 0xf8, 0x8f, 0xb0, 0x0, 0x4, 0xfb, + 0x8f, 0x80, 0x0, 0x2, 0xfc, 0x8f, 0x60, 0x0, + 0x2, 0xfc, 0x8f, 0x60, 0x0, 0x2, 0xfc, 0x8f, + 0x60, 0x0, 0x2, 0xfc, 0x8f, 0x60, 0x0, 0x2, + 0xfc, 0x8f, 0x60, 0x0, 0x2, 0xfc, 0x8f, 0x60, + 0x0, 0x2, 0xfc, 0x8f, 0x60, 0x0, 0x2, 0xfc, + + /* U+0069 "i" */ + 0x8f, 0x68, 0xf6, 0x24, 0x10, 0x0, 0x8f, 0x68, + 0xf6, 0x8f, 0x68, 0xf6, 0x8f, 0x68, 0xf6, 0x8f, + 0x68, 0xf6, 0x8f, 0x68, 0xf6, 0x8f, 0x68, 0xf6, + + /* U+006A "j" */ + 0x0, 0x8f, 0x60, 0x8, 0xf6, 0x0, 0x25, 0x20, + 0x0, 0x0, 0x0, 0x8f, 0x60, 0x8, 0xf6, 0x0, + 0x8f, 0x60, 0x8, 0xf6, 0x0, 0x8f, 0x60, 0x8, + 0xf6, 0x0, 0x8f, 0x60, 0x8, 0xf6, 0x0, 0x8f, + 0x60, 0x8, 0xf6, 0x0, 0x8f, 0x60, 0x8, 0xf6, + 0x0, 0x8f, 0x60, 0xb, 0xf4, 0x9c, 0xff, 0x1c, + 0xfd, 0x40, + + /* U+006B "k" */ + 0x8f, 0x60, 0x0, 0x0, 0x0, 0x8f, 0x60, 0x0, + 0x0, 0x0, 0x8f, 0x60, 0x0, 0x0, 0x0, 0x8f, + 0x60, 0x0, 0x0, 0x0, 0x8f, 0x60, 0x0, 0x8f, + 0xd1, 0x8f, 0x60, 0x7, 0xfe, 0x10, 0x8f, 0x60, + 0x6f, 0xe2, 0x0, 0x8f, 0x65, 0xfe, 0x20, 0x0, + 0x8f, 0xaf, 0xf4, 0x0, 0x0, 0x8f, 0xff, 0xfc, + 0x0, 0x0, 0x8f, 0xe3, 0xdf, 0x60, 0x0, 0x8f, + 0x60, 0x3f, 0xf1, 0x0, 0x8f, 0x60, 0x9, 0xfb, + 0x0, 0x8f, 0x60, 0x1, 0xef, 0x50, 0x8f, 0x60, + 0x0, 0x6f, 0xe1, 0x8f, 0x60, 0x0, 0xc, 0xf9, + + /* U+006C "l" */ + 0x8f, 0x68, 0xf6, 0x8f, 0x68, 0xf6, 0x8f, 0x68, + 0xf6, 0x8f, 0x68, 0xf6, 0x8f, 0x68, 0xf6, 0x8f, + 0x68, 0xf6, 0x8f, 0x68, 0xf6, 0x8f, 0x68, 0xf6, + + /* U+006D "m" */ + 0x9f, 0x26, 0xdf, 0xe8, 0x0, 0x8e, 0xfd, 0x50, + 0x9f, 0xaf, 0xdc, 0xff, 0x8b, 0xfd, 0xdf, 0xf4, + 0x9f, 0xf5, 0x0, 0x4f, 0xfe, 0x30, 0x8, 0xfb, + 0x9f, 0xb0, 0x0, 0xe, 0xf7, 0x0, 0x2, 0xfd, + 0x9f, 0x70, 0x0, 0xc, 0xf3, 0x0, 0x0, 0xfe, + 0x9f, 0x60, 0x0, 0xc, 0xf2, 0x0, 0x0, 0xfe, + 0x9f, 0x60, 0x0, 0xc, 0xf2, 0x0, 0x0, 0xfe, + 0x9f, 0x60, 0x0, 0xc, 0xf2, 0x0, 0x0, 0xfe, + 0x9f, 0x60, 0x0, 0xc, 0xf2, 0x0, 0x0, 0xfe, + 0x9f, 0x60, 0x0, 0xc, 0xf2, 0x0, 0x0, 0xfe, + 0x9f, 0x60, 0x0, 0xc, 0xf2, 0x0, 0x0, 0xfe, + 0x9f, 0x60, 0x0, 0xc, 0xf2, 0x0, 0x0, 0xfe, + + /* U+006E "n" */ + 0x8f, 0x34, 0xcf, 0xea, 0x20, 0x8f, 0xaf, 0xec, + 0xef, 0xf1, 0x8f, 0xf7, 0x0, 0xc, 0xf8, 0x8f, + 0xb0, 0x0, 0x5, 0xfb, 0x8f, 0x80, 0x0, 0x3, + 0xfb, 0x8f, 0x60, 0x0, 0x2, 0xfc, 0x8f, 0x60, + 0x0, 0x2, 0xfc, 0x8f, 0x60, 0x0, 0x2, 0xfc, + 0x8f, 0x60, 0x0, 0x2, 0xfc, 0x8f, 0x60, 0x0, + 0x2, 0xfc, 0x8f, 0x60, 0x0, 0x2, 0xfc, 0x8f, + 0x60, 0x0, 0x2, 0xfc, + + /* U+006F "o" */ + 0x0, 0x5, 0xcf, 0xfd, 0x70, 0x0, 0x0, 0xaf, + 0xfb, 0xbe, 0xfc, 0x0, 0x6, 0xfd, 0x20, 0x0, + 0xbf, 0xa0, 0xd, 0xf4, 0x0, 0x0, 0x1f, 0xf1, + 0x1f, 0xe0, 0x0, 0x0, 0xb, 0xf5, 0x2f, 0xc0, + 0x0, 0x0, 0x9, 0xf7, 0x3f, 0xc0, 0x0, 0x0, + 0x9, 0xf6, 0x1f, 0xe0, 0x0, 0x0, 0xb, 0xf5, + 0xd, 0xf4, 0x0, 0x0, 0x1f, 0xf1, 0x6, 0xfd, + 0x20, 0x0, 0xbf, 0xa0, 0x0, 0xaf, 0xfb, 0xae, + 0xfd, 0x10, 0x0, 0x5, 0xcf, 0xfd, 0x70, 0x0, + + /* U+0070 "p" */ + 0x8f, 0x46, 0xdf, 0xe9, 0x10, 0x8, 0xfb, 0xfb, + 0x9d, 0xfd, 0x10, 0x8f, 0xf6, 0x0, 0xa, 0xf9, + 0x8, 0xfc, 0x0, 0x0, 0x1f, 0xf1, 0x8f, 0x70, + 0x0, 0x0, 0xbf, 0x48, 0xf5, 0x0, 0x0, 0x9, + 0xf5, 0x8f, 0x40, 0x0, 0x0, 0x9f, 0x58, 0xf6, + 0x0, 0x0, 0xb, 0xf3, 0x8f, 0xb0, 0x0, 0x1, + 0xff, 0x8, 0xff, 0x50, 0x0, 0xbf, 0x80, 0x8f, + 0xef, 0xca, 0xef, 0xc0, 0x8, 0xf6, 0x7d, 0xfd, + 0x80, 0x0, 0x8f, 0x60, 0x0, 0x0, 0x0, 0x8, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x8f, 0x60, 0x0, + 0x0, 0x0, 0x8, 0xf6, 0x0, 0x0, 0x0, 0x0, + + /* U+0071 "q" */ + 0x0, 0x7, 0xdf, 0xe8, 0x1f, 0xb0, 0xb, 0xfe, + 0x9b, 0xfb, 0xfb, 0x6, 0xfc, 0x0, 0x3, 0xff, + 0xb0, 0xdf, 0x40, 0x0, 0x9, 0xfb, 0x1f, 0xf0, + 0x0, 0x0, 0x4f, 0xb2, 0xfd, 0x0, 0x0, 0x1, + 0xfb, 0x2f, 0xd0, 0x0, 0x0, 0x1f, 0xb0, 0xff, + 0x0, 0x0, 0x2, 0xfb, 0xc, 0xf5, 0x0, 0x0, + 0x7f, 0xb0, 0x4f, 0xd1, 0x0, 0x3f, 0xfb, 0x0, + 0x9f, 0xfb, 0xbf, 0xef, 0xb0, 0x0, 0x6c, 0xfe, + 0x84, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xb0, + 0x0, 0x0, 0x0, 0x3, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xb0, 0x0, 0x0, 0x0, 0x3, 0xfb, + + /* U+0072 "r" */ + 0x9f, 0x29, 0xfe, 0x59, 0xfa, 0xff, 0xf4, 0x9f, + 0xf7, 0x14, 0x9, 0xfb, 0x0, 0x0, 0x9f, 0x70, + 0x0, 0x9, 0xf6, 0x0, 0x0, 0x9f, 0x50, 0x0, + 0x9, 0xf5, 0x0, 0x0, 0x9f, 0x50, 0x0, 0x9, + 0xf5, 0x0, 0x0, 0x9f, 0x50, 0x0, 0x9, 0xf5, + 0x0, 0x0, + + /* U+0073 "s" */ + 0x0, 0x4b, 0xef, 0xd8, 0x10, 0x0, 0x6f, 0xfb, + 0xad, 0xfe, 0x10, 0xe, 0xf2, 0x0, 0x9, 0xf8, + 0x0, 0xff, 0x0, 0x0, 0x16, 0x30, 0xb, 0xfd, + 0x73, 0x0, 0x0, 0x0, 0x1c, 0xff, 0xfe, 0x93, + 0x0, 0x0, 0x3, 0x8d, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x1, 0x8f, 0xf0, 0x2d, 0xb0, 0x0, 0x0, + 0xef, 0x20, 0xef, 0x50, 0x0, 0x4f, 0xe0, 0x4, + 0xff, 0xca, 0xcf, 0xf5, 0x0, 0x3, 0xad, 0xfe, + 0xb3, 0x0, + + /* U+0074 "t" */ + 0x0, 0x0, 0x0, 0x0, 0x59, 0x0, 0x3, 0xfb, + 0x0, 0x3, 0xfb, 0x0, 0x3, 0xfb, 0x0, 0xaf, + 0xff, 0xfa, 0x5a, 0xfd, 0x85, 0x3, 0xfb, 0x0, + 0x3, 0xfb, 0x0, 0x3, 0xfb, 0x0, 0x3, 0xfb, + 0x0, 0x3, 0xfb, 0x0, 0x3, 0xfb, 0x0, 0x3, + 0xfb, 0x0, 0x3, 0xfd, 0x0, 0x0, 0xff, 0xea, + 0x0, 0x5d, 0xfc, + + /* U+0075 "u" */ + 0x8f, 0x60, 0x0, 0x3, 0xfb, 0x8f, 0x60, 0x0, + 0x3, 0xfb, 0x8f, 0x60, 0x0, 0x3, 0xfb, 0x8f, + 0x60, 0x0, 0x3, 0xfb, 0x8f, 0x60, 0x0, 0x3, + 0xfb, 0x8f, 0x60, 0x0, 0x3, 0xfb, 0x8f, 0x60, + 0x0, 0x3, 0xfb, 0x8f, 0x60, 0x0, 0x5, 0xfb, + 0x7f, 0x80, 0x0, 0x9, 0xfb, 0x4f, 0xe1, 0x0, + 0x4f, 0xfb, 0xd, 0xff, 0xcd, 0xf9, 0xfb, 0x1, + 0x9e, 0xfd, 0x60, 0xfb, + + /* U+0076 "v" */ + 0x8f, 0x70, 0x0, 0x0, 0x6f, 0x92, 0xfd, 0x0, + 0x0, 0xc, 0xf3, 0xd, 0xf2, 0x0, 0x1, 0xfd, + 0x0, 0x7f, 0x80, 0x0, 0x7f, 0x70, 0x1, 0xfd, + 0x0, 0xc, 0xf2, 0x0, 0xb, 0xf3, 0x2, 0xfc, + 0x0, 0x0, 0x5f, 0x80, 0x7f, 0x60, 0x0, 0x0, + 0xfd, 0xd, 0xf1, 0x0, 0x0, 0xa, 0xf5, 0xfa, + 0x0, 0x0, 0x0, 0x4f, 0xef, 0x50, 0x0, 0x0, + 0x0, 0xef, 0xe0, 0x0, 0x0, 0x0, 0x8, 0xf9, + 0x0, 0x0, + + /* U+0077 "w" */ + 0xbf, 0x30, 0x0, 0x2f, 0xf1, 0x0, 0x4, 0xf9, + 0x7f, 0x80, 0x0, 0x6f, 0xf5, 0x0, 0x8, 0xf5, + 0x2f, 0xc0, 0x0, 0xaf, 0xf9, 0x0, 0xd, 0xf0, + 0xd, 0xf0, 0x0, 0xeb, 0xed, 0x0, 0x1f, 0xb0, + 0x9, 0xf4, 0x2, 0xf7, 0xbf, 0x10, 0x6f, 0x60, + 0x4, 0xf8, 0x6, 0xf3, 0x7f, 0x50, 0xaf, 0x20, + 0x0, 0xfc, 0xa, 0xf0, 0x3f, 0x90, 0xfd, 0x0, + 0x0, 0xbf, 0x1e, 0xb0, 0xe, 0xd3, 0xf8, 0x0, + 0x0, 0x6f, 0x7f, 0x70, 0xb, 0xf9, 0xf3, 0x0, + 0x0, 0x2f, 0xef, 0x30, 0x7, 0xff, 0xe0, 0x0, + 0x0, 0xd, 0xff, 0x0, 0x3, 0xff, 0xa0, 0x0, + 0x0, 0x8, 0xfb, 0x0, 0x0, 0xef, 0x50, 0x0, + + /* U+0078 "x" */ + 0x3f, 0xf3, 0x0, 0x2, 0xff, 0x30, 0x8f, 0xc0, + 0x0, 0xcf, 0x70, 0x0, 0xdf, 0x70, 0x7f, 0xc0, + 0x0, 0x3, 0xff, 0x4f, 0xf2, 0x0, 0x0, 0x8, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0xd, 0xfc, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0xcf, 0xaf, 0xc0, 0x0, 0x0, 0x8f, 0xb0, 0xbf, + 0x70, 0x0, 0x3f, 0xf2, 0x2, 0xff, 0x30, 0xd, + 0xf7, 0x0, 0x7, 0xfd, 0x8, 0xfc, 0x0, 0x0, + 0xd, 0xf8, + + /* U+0079 "y" */ + 0x7f, 0x90, 0x0, 0x0, 0x5f, 0x91, 0xff, 0x0, + 0x0, 0xa, 0xf3, 0xb, 0xf5, 0x0, 0x1, 0xfd, + 0x0, 0x4f, 0xb0, 0x0, 0x6f, 0x70, 0x0, 0xef, + 0x10, 0xc, 0xf2, 0x0, 0x8, 0xf6, 0x2, 0xfb, + 0x0, 0x0, 0x2f, 0xc0, 0x8f, 0x50, 0x0, 0x0, + 0xcf, 0x1d, 0xf0, 0x0, 0x0, 0x6, 0xf9, 0xf9, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x30, 0x0, 0x0, + 0x0, 0xaf, 0xd0, 0x0, 0x0, 0x0, 0x6, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0x10, 0x0, 0x0, + 0x0, 0x6f, 0xa0, 0x0, 0x0, 0xc, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x8f, 0xd4, 0x0, 0x0, 0x0, + + /* U+007A "z" */ + 0x2f, 0xff, 0xff, 0xff, 0xff, 0x31, 0x99, 0x99, + 0x99, 0xcf, 0xe1, 0x0, 0x0, 0x0, 0x2e, 0xf3, + 0x0, 0x0, 0x0, 0xd, 0xf6, 0x0, 0x0, 0x0, + 0xb, 0xf9, 0x0, 0x0, 0x0, 0x8, 0xfc, 0x0, + 0x0, 0x0, 0x5, 0xfe, 0x10, 0x0, 0x0, 0x3, + 0xff, 0x30, 0x0, 0x0, 0x1, 0xef, 0x60, 0x0, + 0x0, 0x0, 0xcf, 0x80, 0x0, 0x0, 0x0, 0x8f, + 0xfa, 0xbb, 0xbb, 0xbb, 0x69, 0xff, 0xff, 0xff, + 0xff, 0xf8, + + /* U+007B "{" */ + 0x0, 0x2, 0xbe, 0xd0, 0x0, 0xcf, 0xea, 0x0, + 0xf, 0xd0, 0x0, 0x2, 0xfa, 0x0, 0x0, 0x2f, + 0xa0, 0x0, 0x3, 0xf9, 0x0, 0x0, 0x5f, 0x80, + 0x0, 0xb, 0xf4, 0x0, 0x5f, 0xf7, 0x0, 0x6, + 0xfd, 0x30, 0x0, 0x3, 0xee, 0x0, 0x0, 0x7, + 0xf6, 0x0, 0x0, 0x4f, 0x80, 0x0, 0x2, 0xfa, + 0x0, 0x0, 0x2f, 0xa0, 0x0, 0x2, 0xfa, 0x0, + 0x0, 0x1f, 0xb0, 0x0, 0x0, 0xfd, 0x0, 0x0, + 0xa, 0xfe, 0xa0, 0x0, 0xa, 0xed, + + /* U+007C "|" */ + 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, + 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, + 0xfb, 0xfb, 0xfb, 0xfb, + + /* U+007D "}" */ + 0x8f, 0xd5, 0x0, 0x5, 0xcf, 0xf2, 0x0, 0x0, + 0x7f, 0x60, 0x0, 0x5, 0xf7, 0x0, 0x0, 0x5f, + 0x70, 0x0, 0x4, 0xf8, 0x0, 0x0, 0x2f, 0xa0, + 0x0, 0x0, 0xef, 0x20, 0x0, 0x3, 0xdf, 0xa0, + 0x0, 0xa, 0xfb, 0x0, 0x9, 0xf6, 0x0, 0x1, + 0xfc, 0x0, 0x0, 0x3f, 0x90, 0x0, 0x4, 0xf8, + 0x0, 0x0, 0x4f, 0x70, 0x0, 0x5, 0xf7, 0x0, + 0x0, 0x5f, 0x60, 0x0, 0x8, 0xf5, 0x0, 0x5d, + 0xff, 0x10, 0x8, 0xfc, 0x40, 0x0, + + /* U+007E "~" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xaf, + 0xe9, 0x20, 0x0, 0x7, 0xd, 0xff, 0xff, 0xfa, + 0x32, 0x9e, 0x1f, 0x72, 0x3a, 0xff, 0xff, 0xfb, + 0x6, 0x0, 0x0, 0x3a, 0xee, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+00A0 " " */ + + /* U+00A3 "£" */ + 0x0, 0x2, 0xae, 0xfd, 0x91, 0x0, 0x0, 0x4f, + 0xfd, 0xad, 0xff, 0x30, 0x0, 0xef, 0x60, 0x0, + 0x8f, 0xd0, 0x4, 0xfd, 0x0, 0x0, 0xe, 0xf2, + 0x5, 0xfb, 0x0, 0x0, 0x2, 0x10, 0x3, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x4a, 0xcf, 0xea, 0xa7, 0x0, 0x0, 0x0, 0x4f, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0x50, 0x0, 0x0, 0x0, + 0x1, 0xec, 0x0, 0x0, 0x0, 0x0, 0x1c, 0xf9, + 0x98, 0x52, 0x0, 0x41, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x2c, 0x51, 0x2, 0x7b, 0xee, 0xb4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00A4 "¤" */ + 0x3, 0x50, 0x0, 0x0, 0x2, 0x50, 0xe, 0xf6, + 0xae, 0xfb, 0x5e, 0xf2, 0x3, 0xff, 0xfe, 0xef, + 0xff, 0x70, 0x0, 0xef, 0x50, 0x3, 0xef, 0x20, + 0x4, 0xf9, 0x0, 0x0, 0x5f, 0x80, 0x6, 0xf5, + 0x0, 0x0, 0x2f, 0xa0, 0x4, 0xf9, 0x0, 0x0, + 0x5f, 0x80, 0x0, 0xdf, 0x50, 0x3, 0xef, 0x20, + 0x4, 0xff, 0xfe, 0xef, 0xff, 0x70, 0xe, 0xf6, + 0xae, 0xfb, 0x5e, 0xf2, 0x3, 0x40, 0x0, 0x0, + 0x2, 0x50, + + /* U+00A5 "¥" */ + 0xbf, 0x70, 0x0, 0x0, 0x5, 0xfe, 0x2, 0xff, + 0x10, 0x0, 0x0, 0xef, 0x50, 0x8, 0xf9, 0x0, + 0x0, 0x7f, 0xb0, 0x0, 0xe, 0xf3, 0x0, 0x1f, + 0xf2, 0x0, 0x0, 0x5f, 0xc0, 0x9, 0xf8, 0x0, + 0x0, 0x0, 0xbf, 0x52, 0xfe, 0x0, 0x0, 0x0, + 0x2, 0xfd, 0xbf, 0x50, 0x0, 0x3, 0xaa, 0xae, + 0xff, 0xfa, 0xaa, 0x50, 0x4f, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0xdf, 0x10, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xf1, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x28, 0x88, + 0x8e, 0xf9, 0x88, 0x84, 0x0, 0x0, 0x0, 0xdf, + 0x10, 0x0, 0x0, 0x0, 0x0, 0xd, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0x10, 0x0, 0x0, + + /* U+00A6 "¦" */ + 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, + 0xb8, 0x0, 0x0, 0xb8, 0xfb, 0xfb, 0xfb, 0xfb, + 0xfb, 0xfb, 0xfb, 0xfb, + + /* U+00A7 "§" */ + 0x0, 0x4, 0xcf, 0xec, 0x50, 0x0, 0x0, 0x6f, + 0xfb, 0xbf, 0xf7, 0x0, 0x0, 0xef, 0x30, 0x3, + 0xff, 0x0, 0x0, 0xfe, 0x0, 0x0, 0xac, 0x20, + 0x0, 0xcf, 0x80, 0x0, 0x0, 0x0, 0x0, 0x2e, + 0xfb, 0x20, 0x0, 0x0, 0x1, 0xbf, 0xdf, 0xf7, + 0x0, 0x0, 0xb, 0xf3, 0x8, 0xff, 0xd3, 0x0, + 0xf, 0xb0, 0x0, 0x2d, 0xff, 0x50, 0xf, 0xd0, + 0x0, 0x0, 0xaf, 0xe0, 0x9, 0xf9, 0x0, 0x0, + 0xd, 0xf3, 0x0, 0xaf, 0xc2, 0x0, 0x9, 0xf1, + 0x0, 0x6, 0xef, 0x80, 0x1e, 0x80, 0x0, 0x0, + 0x19, 0xfd, 0xe4, 0x0, 0x0, 0x0, 0x0, 0x4e, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, 0x50, + 0x4, 0xfb, 0x0, 0x0, 0x7f, 0x70, 0x0, 0xff, + 0x50, 0x0, 0xcf, 0x50, 0x0, 0x6f, 0xfc, 0xbe, + 0xfc, 0x0, 0x0, 0x4, 0xbe, 0xfd, 0x70, 0x0, + + /* U+00A8 "¨" */ + 0x14, 0x20, 0x14, 0x25, 0xfa, 0x5, 0xfb, 0x5f, + 0xa0, 0x5f, 0xb0, + + /* U+00A9 "©" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xae, 0xff, 0xfb, 0x50, 0x0, + 0x0, 0x0, 0x8, 0xfd, 0x75, 0x57, 0xcf, 0xc1, + 0x0, 0x0, 0xb, 0xf5, 0x0, 0x0, 0x0, 0x4e, + 0xd1, 0x0, 0x8, 0xf3, 0x3, 0xbf, 0xfc, 0x50, + 0x1e, 0xc0, 0x2, 0xf6, 0x3, 0xfc, 0x54, 0x9f, + 0x50, 0x3f, 0x50, 0x9d, 0x0, 0xbe, 0x0, 0x0, + 0x87, 0x0, 0xbc, 0xd, 0x80, 0xf, 0x70, 0x0, + 0x0, 0x0, 0x5, 0xf0, 0xf6, 0x1, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0x2f, 0x60, 0xf, 0x70, + 0x0, 0x0, 0x0, 0x2, 0xf2, 0xd8, 0x0, 0xcc, + 0x0, 0x0, 0x9c, 0x0, 0x4f, 0x1a, 0xc0, 0x5, + 0xf9, 0x21, 0x8f, 0x70, 0x9, 0xd0, 0x4f, 0x40, + 0x6, 0xef, 0xff, 0x70, 0x1, 0xf7, 0x0, 0xbe, + 0x10, 0x0, 0x22, 0x0, 0x0, 0xcd, 0x0, 0x1, + 0xdd, 0x20, 0x0, 0x0, 0x1, 0xbf, 0x20, 0x0, + 0x1, 0xcf, 0xa5, 0x22, 0x48, 0xfe, 0x30, 0x0, + 0x0, 0x0, 0x6d, 0xff, 0xff, 0xe8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x33, 0x20, 0x0, 0x0, + 0x0, + + /* U+00AA "ª" */ + 0x3, 0xcf, 0xd5, 0xcc, 0x1e, 0xd4, 0x6f, 0xf8, + 0x7f, 0x30, 0x9, 0xf4, 0x9f, 0x0, 0x5, 0xf1, + 0x9f, 0x0, 0x6, 0xf1, 0x7f, 0x30, 0x9, 0xf4, + 0x1e, 0xd4, 0x7f, 0xf8, 0x3, 0xcf, 0xd5, 0xbc, + + /* U+00AB "«" */ + 0x0, 0x0, 0x10, 0x0, 0x10, 0x0, 0x7, 0xf2, + 0x5, 0xf5, 0x0, 0x2f, 0xa0, 0x1e, 0xc0, 0x0, + 0xdf, 0x10, 0xaf, 0x30, 0x8, 0xf8, 0x5, 0xfa, + 0x0, 0x3f, 0xe0, 0x1e, 0xf2, 0x0, 0x2f, 0xe1, + 0x1e, 0xf2, 0x0, 0x7, 0xf8, 0x4, 0xfb, 0x0, + 0x0, 0xcf, 0x20, 0x9f, 0x40, 0x0, 0x2f, 0xa0, + 0xe, 0xd0, 0x0, 0x6, 0xf3, 0x4, 0xf6, + + /* U+00AC "¬" */ + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xaa, 0xdd, 0xdd, + 0xdd, 0xde, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xa0, 0x0, 0x0, 0x0, 0x3, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xa0, 0x0, 0x0, 0x0, 0x3, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x2d, 0x80, + + /* U+00AD "­" */ + 0x4f, 0xff, 0xff, 0xa4, 0xff, 0xff, 0xfa, + + /* U+00AE "®" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xae, 0xff, 0xfb, 0x50, 0x0, + 0x0, 0x0, 0x8, 0xfd, 0x75, 0x57, 0xcf, 0xc1, + 0x0, 0x0, 0xb, 0xf5, 0x0, 0x0, 0x0, 0x4e, + 0xd1, 0x0, 0x8, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xc0, 0x2, 0xf6, 0x7, 0xff, 0xff, 0xc4, + 0x0, 0x3f, 0x50, 0x9d, 0x0, 0x7f, 0x33, 0x4b, + 0xf1, 0x0, 0xbc, 0xd, 0x80, 0x7, 0xf0, 0x0, + 0x4f, 0x30, 0x5, 0xf0, 0xf6, 0x0, 0x7f, 0x0, + 0x2a, 0xe1, 0x0, 0x3f, 0x2f, 0x60, 0x7, 0xff, + 0xff, 0xd4, 0x0, 0x2, 0xf2, 0xd8, 0x0, 0x7f, + 0x35, 0xe7, 0x0, 0x0, 0x4f, 0x1a, 0xc0, 0x7, + 0xf0, 0x3, 0xf6, 0x0, 0x9, 0xd0, 0x4f, 0x40, + 0x7f, 0x0, 0x9, 0xf1, 0x1, 0xf7, 0x0, 0xbe, + 0x15, 0xb0, 0x0, 0x1b, 0x70, 0xcd, 0x0, 0x1, + 0xdd, 0x20, 0x0, 0x0, 0x1, 0xbf, 0x20, 0x0, + 0x1, 0xcf, 0xa5, 0x22, 0x48, 0xfe, 0x30, 0x0, + 0x0, 0x0, 0x6d, 0xff, 0xff, 0xe8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x33, 0x20, 0x0, 0x0, + 0x0, + + /* U+00B0 "°" */ + 0x3, 0xcf, 0xb2, 0x2, 0xf8, 0x3a, 0xd0, 0x7b, + 0x0, 0xe, 0x48, 0xa0, 0x0, 0xe4, 0x3f, 0x51, + 0x7e, 0x10, 0x6f, 0xfe, 0x40, 0x0, 0x2, 0x0, + 0x0, + + /* U+00B1 "±" */ + 0x0, 0x0, 0x5b, 0x30, 0x0, 0x0, 0x0, 0x7, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x7f, 0x50, 0x0, + 0x0, 0x0, 0x7, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0x50, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0xad, 0xdd, 0xef, 0xed, 0xdd, 0x80, 0x0, + 0x7, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x7f, 0x50, + 0x0, 0x0, 0x0, 0x7, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xad, 0xdd, 0xdd, 0xdd, 0xdd, 0x8c, + 0xff, 0xff, 0xff, 0xff, 0xfa, + + /* U+00B2 "²" */ + 0x4, 0xcf, 0xea, 0x12, 0xfb, 0x56, 0xfb, 0x26, + 0x10, 0xd, 0xd0, 0x0, 0x6, 0xf7, 0x0, 0x9, + 0xf9, 0x0, 0x1d, 0xf5, 0x0, 0x1d, 0xf7, 0x44, + 0x49, 0xff, 0xff, 0xff, + + /* U+00B3 "³" */ + 0x6, 0xdf, 0xe9, 0x3, 0xfa, 0x37, 0xf7, 0x1, + 0x0, 0x6f, 0x60, 0x0, 0xef, 0xa0, 0x0, 0x2, + 0x5f, 0x93, 0x60, 0x0, 0xce, 0x5f, 0x94, 0x8f, + 0xa0, 0x6d, 0xfe, 0x90, + + /* U+00B5 "µ" */ + 0x8f, 0x60, 0x0, 0x3, 0xfb, 0x8f, 0x60, 0x0, + 0x3, 0xfb, 0x8f, 0x60, 0x0, 0x3, 0xfb, 0x8f, + 0x60, 0x0, 0x3, 0xfb, 0x8f, 0x60, 0x0, 0x3, + 0xfb, 0x8f, 0x60, 0x0, 0x3, 0xfb, 0x8f, 0x70, + 0x0, 0x3, 0xfb, 0x8f, 0x80, 0x0, 0x4, 0xfb, + 0x8f, 0xb0, 0x0, 0x8, 0xfb, 0x8f, 0xf6, 0x0, + 0x4f, 0xfb, 0x8f, 0xef, 0xee, 0xfd, 0xfb, 0x8f, + 0x78, 0xef, 0xb2, 0xfb, 0x8f, 0x60, 0x0, 0x0, + 0x0, 0x8f, 0x60, 0x0, 0x0, 0x0, 0x8f, 0x60, + 0x0, 0x0, 0x0, 0x8f, 0x60, 0x0, 0x0, 0x0, + + /* U+00B6 "¶" */ + 0x0, 0x18, 0xdf, 0xff, 0xff, 0xff, 0xd0, 0x1d, + 0xff, 0xff, 0xee, 0xff, 0xec, 0x9, 0xff, 0xff, + 0xf1, 0x8, 0xf4, 0x0, 0xef, 0xff, 0xff, 0x10, + 0x8f, 0x40, 0xf, 0xff, 0xff, 0xf1, 0x8, 0xf4, + 0x0, 0xef, 0xff, 0xff, 0x10, 0x8f, 0x40, 0x9, + 0xff, 0xff, 0xf1, 0x8, 0xf4, 0x0, 0x1d, 0xff, + 0xff, 0x10, 0x8f, 0x40, 0x0, 0x7, 0xcf, 0xf1, + 0x8, 0xf4, 0x0, 0x0, 0x0, 0xbf, 0x10, 0x8f, + 0x40, 0x0, 0x0, 0xb, 0xf1, 0x8, 0xf4, 0x0, + 0x0, 0x0, 0xbf, 0x10, 0x8f, 0x40, 0x0, 0x0, + 0xb, 0xf1, 0x8, 0xf4, 0x0, 0x0, 0x0, 0xbf, + 0x10, 0x8f, 0x40, 0x0, 0x0, 0xb, 0xf1, 0x8, + 0xf4, 0x0, 0x0, 0x0, 0xbf, 0x10, 0x8f, 0x40, + 0x0, 0x0, 0xb, 0xf1, 0x8, 0xf4, 0x0, 0x0, + 0x0, 0xbf, 0x10, 0x8f, 0x40, 0x0, 0x0, 0xb, + 0xf1, 0x8, 0xf4, 0x0, 0x0, 0x0, 0xbf, 0x10, + 0x8f, 0x40, + + /* U+00B7 "·" */ + 0x4, 0x40, 0xf, 0xf2, 0xf, 0xf2, + + /* U+00BB "»" */ + 0x1, 0x0, 0x1, 0x0, 0x0, 0x2f, 0x80, 0xe, + 0xb0, 0x0, 0x9, 0xf3, 0x6, 0xf6, 0x0, 0x1, + 0xed, 0x0, 0xdf, 0x20, 0x0, 0x7f, 0x90, 0x4f, + 0xb0, 0x0, 0xd, 0xf3, 0xb, 0xf6, 0x0, 0xe, + 0xf3, 0xb, 0xf6, 0x0, 0x7f, 0x80, 0x4f, 0xb0, + 0x1, 0xfd, 0x0, 0xde, 0x10, 0x9, 0xf3, 0x6, + 0xf5, 0x0, 0x2f, 0x80, 0xe, 0xa0, 0x0, + + /* U+00BD "½" */ + 0x0, 0x16, 0x0, 0x0, 0x0, 0x0, 0x5, 0x50, + 0x0, 0x1c, 0xf1, 0x0, 0x0, 0x0, 0x5, 0xf5, + 0x0, 0x6e, 0xff, 0x10, 0x0, 0x0, 0x1, 0xea, + 0x0, 0xc, 0x87, 0xf1, 0x0, 0x0, 0x0, 0xbe, + 0x10, 0x0, 0x0, 0x7f, 0x10, 0x0, 0x0, 0x6f, + 0x40, 0x0, 0x0, 0x7, 0xf1, 0x0, 0x0, 0x2f, + 0x90, 0x0, 0x0, 0x0, 0x7f, 0x10, 0x0, 0xc, + 0xd0, 0x0, 0x0, 0x0, 0x7, 0xf1, 0x0, 0x7, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x6f, 0x10, 0x2, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdd, 0x0, 0x5d, 0xff, 0xb2, 0x0, 0x0, 0x0, + 0x8f, 0x20, 0x2f, 0xb5, 0x6f, 0xb0, 0x0, 0x0, + 0x3f, 0x70, 0x2, 0x71, 0x0, 0xdd, 0x0, 0x0, + 0xd, 0xc0, 0x0, 0x0, 0x0, 0x5f, 0x80, 0x0, + 0x9, 0xf2, 0x0, 0x0, 0x0, 0x7f, 0xb0, 0x0, + 0x4, 0xf6, 0x0, 0x0, 0x0, 0xbf, 0x80, 0x0, + 0x1, 0xeb, 0x0, 0x0, 0x0, 0xcf, 0x61, 0x11, + 0x0, 0xae, 0x10, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xf0, 0x3c, 0x40, 0x0, 0x0, 0x2, 0x44, 0x44, + 0x44, + + /* U+0384 "΄" */ + 0x0, 0x11, 0x0, 0x7f, 0xd0, 0xe, 0xf2, 0x6, + 0xf5, 0x0, + + /* U+0386 "Ά" */ + 0x0, 0x3f, 0xf3, 0x2f, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0x60, 0x8f, 0xfe, 0x0, 0x0, 0x0, + 0x2, 0xfa, 0x0, 0xee, 0xaf, 0x40, 0x0, 0x0, + 0x0, 0x10, 0x4, 0xf9, 0x4f, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xf5, 0xe, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xe0, 0x8, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0x90, 0x2, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0x30, 0x0, 0xcf, 0x40, 0x0, + 0x0, 0x2, 0xfd, 0x0, 0x0, 0x6f, 0xb0, 0x0, + 0x0, 0x8, 0xfe, 0xcc, 0xcc, 0xcf, 0xf1, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x5f, 0xc0, 0x0, 0x0, 0x4, 0xfe, 0x0, + 0x0, 0xbf, 0x60, 0x0, 0x0, 0x0, 0xef, 0x50, + 0x1, 0xff, 0x10, 0x0, 0x0, 0x0, 0x9f, 0xb0, + 0x7, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf2, + 0xd, 0xf6, 0x0, 0x0, 0x0, 0x0, 0xd, 0xf8, + + /* U+0388 "Έ" */ + 0xc, 0xfa, 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xb0, 0x3f, 0xd0, 0xb, 0xff, 0xee, 0xee, 0xee, + 0xee, 0x90, 0xaf, 0x20, 0xb, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x11, 0x0, 0xb, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0x10, + 0x0, 0x0, 0xb, 0xff, 0xee, 0xee, 0xee, 0xee, + 0x10, 0x0, 0x0, 0xb, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xee, 0xee, 0xee, 0xee, 0xe0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + + /* U+0389 "Ή" */ + 0xc, 0xfa, 0x2f, 0xf0, 0x0, 0x0, 0x0, 0xd, + 0xf3, 0x3f, 0xd0, 0x2f, 0xf0, 0x0, 0x0, 0x0, + 0xd, 0xf3, 0xaf, 0x20, 0x2f, 0xf0, 0x0, 0x0, + 0x0, 0xd, 0xf3, 0x11, 0x0, 0x2f, 0xf0, 0x0, + 0x0, 0x0, 0xd, 0xf3, 0x0, 0x0, 0x2f, 0xf0, + 0x0, 0x0, 0x0, 0xd, 0xf3, 0x0, 0x0, 0x2f, + 0xf0, 0x0, 0x0, 0x0, 0xd, 0xf3, 0x0, 0x0, + 0x2f, 0xfe, 0xee, 0xee, 0xee, 0xef, 0xf3, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x2f, 0xf0, 0x0, 0x0, 0x0, 0xd, + 0xf3, 0x0, 0x0, 0x2f, 0xf0, 0x0, 0x0, 0x0, + 0xd, 0xf3, 0x0, 0x0, 0x2f, 0xf0, 0x0, 0x0, + 0x0, 0xd, 0xf3, 0x0, 0x0, 0x2f, 0xf0, 0x0, + 0x0, 0x0, 0xd, 0xf3, 0x0, 0x0, 0x2f, 0xf0, + 0x0, 0x0, 0x0, 0xd, 0xf3, 0x0, 0x0, 0x2f, + 0xf0, 0x0, 0x0, 0x0, 0xd, 0xf3, 0x0, 0x0, + 0x2f, 0xf0, 0x0, 0x0, 0x0, 0xd, 0xf3, 0x0, + 0x0, 0x2f, 0xf0, 0x0, 0x0, 0x0, 0xd, 0xf3, + + /* U+038A "Ί" */ + 0xc, 0xfa, 0x2f, 0xf3, 0xfd, 0x2, 0xff, 0xaf, + 0x20, 0x2f, 0xf1, 0x10, 0x2, 0xff, 0x0, 0x0, + 0x2f, 0xf0, 0x0, 0x2, 0xff, 0x0, 0x0, 0x2f, + 0xf0, 0x0, 0x2, 0xff, 0x0, 0x0, 0x2f, 0xf0, + 0x0, 0x2, 0xff, 0x0, 0x0, 0x2f, 0xf0, 0x0, + 0x2, 0xff, 0x0, 0x0, 0x2f, 0xf0, 0x0, 0x2, + 0xff, 0x0, 0x0, 0x2f, 0xf0, 0x0, 0x2, 0xff, + + /* U+038C "Ό" */ + 0xc, 0xfa, 0x0, 0x6b, 0xef, 0xeb, 0x60, 0x0, + 0x3, 0xfd, 0x3, 0xef, 0xff, 0xdf, 0xff, 0xd2, + 0x0, 0xaf, 0x23, 0xff, 0xb3, 0x0, 0x3, 0xcf, + 0xf2, 0x1, 0x10, 0xdf, 0x90, 0x0, 0x0, 0x0, + 0xaf, 0xd0, 0x0, 0x6f, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0x50, 0xb, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xfa, 0x0, 0xef, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xd0, 0xf, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0x0, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xf0, 0xe, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xfe, 0x0, 0xbf, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xa0, 0x5, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xf5, 0x0, 0xd, + 0xf9, 0x0, 0x0, 0x0, 0xa, 0xfd, 0x0, 0x0, + 0x3f, 0xfb, 0x30, 0x0, 0x3b, 0xff, 0x20, 0x0, + 0x0, 0x2e, 0xff, 0xed, 0xff, 0xfd, 0x30, 0x0, + 0x0, 0x0, 0x6, 0xce, 0xfe, 0xb6, 0x0, 0x0, + + /* U+038E "Ύ" */ + 0xc, 0xfa, 0x9, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xf3, 0x3f, 0xd0, 0x0, 0xef, 0x90, 0x0, + 0x0, 0x0, 0xdf, 0x70, 0xaf, 0x20, 0x0, 0x4f, + 0xf3, 0x0, 0x0, 0x8, 0xfc, 0x0, 0x11, 0x0, + 0x0, 0xa, 0xfd, 0x0, 0x0, 0x2f, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0x70, 0x0, 0xcf, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf2, + 0x7, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xfb, 0x1f, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xdf, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xf3, 0x0, 0x0, 0x0, + + /* U+038F "Ώ" */ + 0xc, 0xfa, 0x0, 0x6c, 0xef, 0xdb, 0x40, 0x0, + 0x3, 0xfd, 0x2, 0xdf, 0xfe, 0xdf, 0xff, 0xa0, + 0x0, 0xaf, 0x21, 0xef, 0xc3, 0x0, 0x6, 0xff, + 0xb0, 0x1, 0x10, 0xbf, 0xd0, 0x0, 0x0, 0x3, + 0xff, 0x50, 0x0, 0x1f, 0xf3, 0x0, 0x0, 0x0, + 0x8, 0xfc, 0x0, 0x7, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xf1, 0x0, 0x9f, 0x90, 0x0, 0x0, + 0x0, 0x0, 0xef, 0x30, 0xa, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xf5, 0x0, 0x8f, 0x90, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0x30, 0x6, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xf1, 0x0, 0x1f, 0xe0, + 0x0, 0x0, 0x0, 0x3, 0xfb, 0x0, 0x0, 0x9f, + 0x60, 0x0, 0x0, 0x0, 0xaf, 0x40, 0x0, 0x0, + 0xdf, 0x20, 0x0, 0x0, 0x5f, 0x90, 0x0, 0x0, + 0x2, 0xee, 0x40, 0x0, 0x7f, 0xa0, 0x0, 0x0, + 0xce, 0xef, 0xff, 0x30, 0x8f, 0xfe, 0xee, 0x70, + 0xd, 0xff, 0xff, 0xf4, 0x9, 0xff, 0xff, 0xf8, + + /* U+0390 "ΐ" */ + 0x7f, 0x60, 0xcd, 0xaf, 0x57, 0xf6, 0x7d, 0x18, + 0xf5, 0x2, 0x1, 0x0, 0x12, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xf6, 0x0, 0x0, 0x0, + 0x8f, 0x60, 0x0, 0x0, 0x8, 0xf6, 0x0, 0x0, + 0x0, 0x8f, 0x60, 0x0, 0x0, 0x8, 0xf6, 0x0, + 0x0, 0x0, 0x8f, 0x60, 0x0, 0x0, 0x8, 0xf6, + 0x0, 0x0, 0x0, 0x8f, 0x60, 0x0, 0x0, 0x8, + 0xf6, 0x0, 0x0, 0x0, 0x8f, 0x60, 0x0, 0x0, + 0x8, 0xf6, 0x0, 0x0, 0x0, 0x8f, 0x60, 0x0, + + /* U+0391 "Α" */ + 0x0, 0x0, 0x0, 0x2f, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xed, 0xaf, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xf9, 0x4f, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xf4, 0xe, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xe0, 0x8, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0x90, 0x2, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0x30, 0x0, 0xcf, 0x40, 0x0, + 0x0, 0x2, 0xfd, 0x0, 0x0, 0x6f, 0xb0, 0x0, + 0x0, 0x8, 0xfe, 0xcc, 0xcc, 0xcf, 0xf1, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x5f, 0xc0, 0x0, 0x0, 0x4, 0xfe, 0x0, + 0x0, 0xbf, 0x60, 0x0, 0x0, 0x0, 0xef, 0x50, + 0x1, 0xff, 0x10, 0x0, 0x0, 0x0, 0x9f, 0xb0, + 0x7, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf2, + 0xd, 0xf6, 0x0, 0x0, 0x0, 0x0, 0xd, 0xf8, + + /* U+0392 "Β" */ + 0x6f, 0xff, 0xff, 0xfe, 0xc6, 0x0, 0x6, 0xff, + 0xee, 0xee, 0xff, 0xfa, 0x0, 0x6f, 0xb0, 0x0, + 0x0, 0x5f, 0xf5, 0x6, 0xfb, 0x0, 0x0, 0x0, + 0x7f, 0xa0, 0x6f, 0xb0, 0x0, 0x0, 0x5, 0xfb, + 0x6, 0xfb, 0x0, 0x0, 0x0, 0x8f, 0x80, 0x6f, + 0xb0, 0x0, 0x1, 0x6f, 0xe1, 0x6, 0xff, 0xff, + 0xff, 0xff, 0xe2, 0x0, 0x6f, 0xfe, 0xee, 0xef, + 0xff, 0xd2, 0x6, 0xfb, 0x0, 0x0, 0x2, 0xaf, + 0xd0, 0x6f, 0xb0, 0x0, 0x0, 0x0, 0xdf, 0x56, + 0xfb, 0x0, 0x0, 0x0, 0xb, 0xf7, 0x6f, 0xb0, + 0x0, 0x0, 0x0, 0xdf, 0x66, 0xfb, 0x0, 0x0, + 0x2, 0xaf, 0xf1, 0x6f, 0xfe, 0xee, 0xef, 0xff, + 0xf5, 0x6, 0xff, 0xff, 0xff, 0xfd, 0x93, 0x0, + + /* U+0393 "Γ" */ + 0x3f, 0xff, 0xff, 0xff, 0xff, 0x93, 0xff, 0xee, + 0xee, 0xee, 0xe8, 0x3f, 0xd0, 0x0, 0x0, 0x0, + 0x3, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xd0, + 0x0, 0x0, 0x0, 0x3, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xd0, 0x0, 0x0, 0x0, 0x3, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xd0, 0x0, 0x0, + 0x0, 0x3, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xd0, 0x0, 0x0, 0x0, 0x3, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xd0, 0x0, 0x0, 0x0, 0x3, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xd0, 0x0, + 0x0, 0x0, 0x3, 0xfd, 0x0, 0x0, 0x0, 0x0, + + /* U+0394 "Δ" */ + 0x0, 0x0, 0x0, 0x2f, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xee, 0xaf, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xfa, 0x5f, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xf5, 0xe, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xf0, 0x9, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0x90, 0x3, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0x40, 0x0, 0xdf, 0x40, 0x0, + 0x0, 0x2, 0xfe, 0x0, 0x0, 0x7f, 0xb0, 0x0, + 0x0, 0x8, 0xf8, 0x0, 0x0, 0x1f, 0xf1, 0x0, + 0x0, 0xe, 0xf2, 0x0, 0x0, 0xb, 0xf7, 0x0, + 0x0, 0x5f, 0xc0, 0x0, 0x0, 0x5, 0xfe, 0x0, + 0x0, 0xbf, 0x70, 0x0, 0x0, 0x0, 0xff, 0x40, + 0x1, 0xff, 0x10, 0x0, 0x0, 0x0, 0x9f, 0xb0, + 0x7, 0xff, 0xee, 0xee, 0xee, 0xee, 0xff, 0xf1, + 0xd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + + /* U+0395 "Ε" */ + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x24, 0xff, + 0xee, 0xee, 0xee, 0xee, 0xe1, 0x4f, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x80, 0x4f, 0xfe, 0xee, 0xee, + 0xee, 0xe7, 0x4, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xfe, 0xee, 0xee, 0xee, + 0xee, 0x74, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + + /* U+0396 "Ζ" */ + 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x9e, + 0xee, 0xee, 0xee, 0xef, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0x20, 0x0, 0x0, 0x0, 0x4, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x2, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xd1, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x6, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x3, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xfe, 0xee, 0xee, 0xee, + 0xee, 0xc9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + + /* U+0397 "Η" */ + 0x3f, 0xd0, 0x0, 0x0, 0x0, 0xf, 0xf1, 0x3f, + 0xd0, 0x0, 0x0, 0x0, 0xf, 0xf1, 0x3f, 0xd0, + 0x0, 0x0, 0x0, 0xf, 0xf1, 0x3f, 0xd0, 0x0, + 0x0, 0x0, 0xf, 0xf1, 0x3f, 0xd0, 0x0, 0x0, + 0x0, 0xf, 0xf1, 0x3f, 0xd0, 0x0, 0x0, 0x0, + 0xf, 0xf1, 0x3f, 0xfe, 0xee, 0xee, 0xee, 0xef, + 0xf1, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0x3f, 0xd0, 0x0, 0x0, 0x0, 0xf, 0xf1, 0x3f, + 0xd0, 0x0, 0x0, 0x0, 0xf, 0xf1, 0x3f, 0xd0, + 0x0, 0x0, 0x0, 0xf, 0xf1, 0x3f, 0xd0, 0x0, + 0x0, 0x0, 0xf, 0xf1, 0x3f, 0xd0, 0x0, 0x0, + 0x0, 0xf, 0xf1, 0x3f, 0xd0, 0x0, 0x0, 0x0, + 0xf, 0xf1, 0x3f, 0xd0, 0x0, 0x0, 0x0, 0xf, + 0xf1, 0x3f, 0xd0, 0x0, 0x0, 0x0, 0xf, 0xf1, + + /* U+0398 "Θ" */ + 0x0, 0x0, 0x6b, 0xef, 0xec, 0x70, 0x0, 0x0, + 0x0, 0x2d, 0xff, 0xfd, 0xff, 0xfe, 0x30, 0x0, + 0x2, 0xff, 0xc3, 0x0, 0x3, 0xbf, 0xf3, 0x0, + 0xd, 0xfa, 0x0, 0x0, 0x0, 0x9, 0xfe, 0x0, + 0x4f, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0x60, + 0x9f, 0x80, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xc0, + 0xdf, 0x50, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf0, + 0xef, 0x30, 0x8f, 0xff, 0xff, 0xa0, 0x1f, 0xf0, + 0xef, 0x30, 0x7e, 0xee, 0xee, 0x90, 0x1f, 0xf0, + 0xdf, 0x40, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf0, + 0x9f, 0x80, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xc0, + 0x4f, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0x60, + 0xc, 0xfa, 0x0, 0x0, 0x0, 0x9, 0xfe, 0x0, + 0x2, 0xef, 0xc3, 0x0, 0x3, 0xbf, 0xf3, 0x0, + 0x0, 0x2d, 0xff, 0xfd, 0xef, 0xfe, 0x30, 0x0, + 0x0, 0x0, 0x6b, 0xef, 0xec, 0x70, 0x0, 0x0, + + /* U+0399 "Ι" */ + 0xff, 0x1f, 0xf1, 0xff, 0x1f, 0xf1, 0xff, 0x1f, + 0xf1, 0xff, 0x1f, 0xf1, 0xff, 0x1f, 0xf1, 0xff, + 0x1f, 0xf1, 0xff, 0x1f, 0xf1, 0xff, 0x1f, 0xf1, + + /* U+039A "Κ" */ + 0x6f, 0xb0, 0x0, 0x0, 0x1, 0xdf, 0xc1, 0x6f, + 0xb0, 0x0, 0x0, 0x1d, 0xfc, 0x0, 0x6f, 0xb0, + 0x0, 0x1, 0xdf, 0xc0, 0x0, 0x6f, 0xb0, 0x0, + 0x1d, 0xfb, 0x0, 0x0, 0x6f, 0xb0, 0x1, 0xdf, + 0xb0, 0x0, 0x0, 0x6f, 0xb0, 0x1d, 0xfb, 0x0, + 0x0, 0x0, 0x6f, 0xb1, 0xcf, 0xe0, 0x0, 0x0, + 0x0, 0x6f, 0xcc, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xa5, 0xff, 0x30, 0x0, 0x0, 0x6f, + 0xfa, 0x0, 0x9f, 0xd0, 0x0, 0x0, 0x6f, 0xc0, + 0x0, 0xd, 0xfa, 0x0, 0x0, 0x6f, 0xb0, 0x0, + 0x3, 0xff, 0x60, 0x0, 0x6f, 0xb0, 0x0, 0x0, + 0x8f, 0xf2, 0x0, 0x6f, 0xb0, 0x0, 0x0, 0xd, + 0xfc, 0x0, 0x6f, 0xb0, 0x0, 0x0, 0x2, 0xff, + 0x80, 0x6f, 0xb0, 0x0, 0x0, 0x0, 0x7f, 0xf4, + + /* U+039B "Λ" */ + 0x0, 0x0, 0x0, 0xef, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xf8, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xfc, 0x2f, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0x70, 0xcf, 0x20, 0x0, 0x0, 0x0, 0xd, + 0xf1, 0x6, 0xf8, 0x0, 0x0, 0x0, 0x3, 0xfb, + 0x0, 0x1f, 0xe0, 0x0, 0x0, 0x0, 0x9f, 0x50, + 0x0, 0xbf, 0x40, 0x0, 0x0, 0xf, 0xf0, 0x0, + 0x6, 0xfa, 0x0, 0x0, 0x6, 0xfa, 0x0, 0x0, + 0xf, 0xf1, 0x0, 0x0, 0xcf, 0x40, 0x0, 0x0, + 0xaf, 0x60, 0x0, 0x2f, 0xe0, 0x0, 0x0, 0x5, + 0xfc, 0x0, 0x8, 0xf8, 0x0, 0x0, 0x0, 0xf, + 0xf3, 0x0, 0xef, 0x20, 0x0, 0x0, 0x0, 0xaf, + 0x90, 0x4f, 0xc0, 0x0, 0x0, 0x0, 0x4, 0xfe, + 0xa, 0xf6, 0x0, 0x0, 0x0, 0x0, 0xe, 0xf5, + + /* U+039C "Μ" */ + 0x5f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xfb, + 0x5f, 0xff, 0x40, 0x0, 0x0, 0x0, 0xaf, 0xfb, + 0x5f, 0xef, 0x90, 0x0, 0x0, 0x0, 0xff, 0xfb, + 0x5f, 0xaf, 0xe0, 0x0, 0x0, 0x4, 0xfb, 0xfb, + 0x5f, 0xaa, 0xf4, 0x0, 0x0, 0xa, 0xf6, 0xfb, + 0x5f, 0xa4, 0xf9, 0x0, 0x0, 0xf, 0xa5, 0xfb, + 0x5f, 0xa0, 0xfe, 0x0, 0x0, 0x5f, 0x55, 0xfb, + 0x5f, 0xa0, 0xaf, 0x40, 0x0, 0xaf, 0x5, 0xfb, + 0x5f, 0xa0, 0x4f, 0x90, 0x0, 0xfa, 0x5, 0xfb, + 0x5f, 0xa0, 0xe, 0xe0, 0x5, 0xf5, 0x5, 0xfb, + 0x5f, 0xa0, 0xa, 0xf3, 0xa, 0xf0, 0x5, 0xfb, + 0x5f, 0xa0, 0x4, 0xf9, 0xf, 0xa0, 0x5, 0xfb, + 0x5f, 0xa0, 0x0, 0xee, 0x5f, 0x40, 0x5, 0xfb, + 0x5f, 0xa0, 0x0, 0x9f, 0xde, 0x0, 0x5, 0xfb, + 0x5f, 0xa0, 0x0, 0x4f, 0xf9, 0x0, 0x5, 0xfb, + 0x5f, 0xa0, 0x0, 0xe, 0xf4, 0x0, 0x5, 0xfb, + + /* U+039D "Ν" */ + 0x4f, 0xf3, 0x0, 0x0, 0x0, 0xd, 0xf2, 0x4f, + 0xfd, 0x0, 0x0, 0x0, 0xd, 0xf2, 0x4f, 0xff, + 0x80, 0x0, 0x0, 0xd, 0xf2, 0x4f, 0xef, 0xf3, + 0x0, 0x0, 0xd, 0xf2, 0x4f, 0xb8, 0xfd, 0x0, + 0x0, 0xd, 0xf2, 0x4f, 0xb0, 0xdf, 0x70, 0x0, + 0xd, 0xf2, 0x4f, 0xb0, 0x3f, 0xf2, 0x0, 0xd, + 0xf2, 0x4f, 0xb0, 0x9, 0xfc, 0x0, 0xd, 0xf2, + 0x4f, 0xb0, 0x0, 0xdf, 0x70, 0xd, 0xf2, 0x4f, + 0xb0, 0x0, 0x4f, 0xf2, 0xd, 0xf2, 0x4f, 0xb0, + 0x0, 0x9, 0xfc, 0xd, 0xf2, 0x4f, 0xb0, 0x0, + 0x0, 0xef, 0x7d, 0xf2, 0x4f, 0xb0, 0x0, 0x0, + 0x4f, 0xfe, 0xf2, 0x4f, 0xb0, 0x0, 0x0, 0xa, + 0xff, 0xf2, 0x4f, 0xb0, 0x0, 0x0, 0x1, 0xef, + 0xf2, 0x4f, 0xb0, 0x0, 0x0, 0x0, 0x5f, 0xf2, + + /* U+039E "Ξ" */ + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x7, 0xee, + 0xee, 0xee, 0xee, 0xee, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xfd, 0x0, 0x7, 0xee, 0xee, 0xee, + 0xee, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xce, 0xee, 0xee, 0xee, 0xee, + 0xee, 0x1d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + + /* U+039F "Ο" */ + 0x0, 0x0, 0x6b, 0xef, 0xec, 0x70, 0x0, 0x0, + 0x0, 0x2d, 0xff, 0xfd, 0xff, 0xfe, 0x30, 0x0, + 0x2, 0xff, 0xc3, 0x0, 0x3, 0xbf, 0xf3, 0x0, + 0xd, 0xfa, 0x0, 0x0, 0x0, 0x9, 0xfe, 0x0, + 0x4f, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0x60, + 0x9f, 0x80, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xc0, + 0xdf, 0x50, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf0, + 0xef, 0x30, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf0, + 0xef, 0x30, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf0, + 0xdf, 0x40, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf0, + 0x9f, 0x80, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xc0, + 0x4f, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0x60, + 0xc, 0xfa, 0x0, 0x0, 0x0, 0x9, 0xfe, 0x0, + 0x2, 0xef, 0xc3, 0x0, 0x3, 0xbf, 0xf3, 0x0, + 0x0, 0x2d, 0xff, 0xfd, 0xef, 0xfe, 0x30, 0x0, + 0x0, 0x0, 0x6b, 0xef, 0xec, 0x70, 0x0, 0x0, + + /* U+03A0 "Π" */ + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0x3f, + 0xfe, 0xee, 0xee, 0xee, 0xef, 0xf1, 0x3f, 0xd0, + 0x0, 0x0, 0x0, 0xf, 0xf1, 0x3f, 0xd0, 0x0, + 0x0, 0x0, 0xf, 0xf1, 0x3f, 0xd0, 0x0, 0x0, + 0x0, 0xf, 0xf1, 0x3f, 0xd0, 0x0, 0x0, 0x0, + 0xf, 0xf1, 0x3f, 0xd0, 0x0, 0x0, 0x0, 0xf, + 0xf1, 0x3f, 0xd0, 0x0, 0x0, 0x0, 0xf, 0xf1, + 0x3f, 0xd0, 0x0, 0x0, 0x0, 0xf, 0xf1, 0x3f, + 0xd0, 0x0, 0x0, 0x0, 0xf, 0xf1, 0x3f, 0xd0, + 0x0, 0x0, 0x0, 0xf, 0xf1, 0x3f, 0xd0, 0x0, + 0x0, 0x0, 0xf, 0xf1, 0x3f, 0xd0, 0x0, 0x0, + 0x0, 0xf, 0xf1, 0x3f, 0xd0, 0x0, 0x0, 0x0, + 0xf, 0xf1, 0x3f, 0xd0, 0x0, 0x0, 0x0, 0xf, + 0xf1, 0x3f, 0xd0, 0x0, 0x0, 0x0, 0xf, 0xf1, + + /* U+03A1 "Ρ" */ + 0x4f, 0xff, 0xff, 0xff, 0xeb, 0x50, 0x4, 0xff, + 0xee, 0xee, 0xef, 0xff, 0xa0, 0x4f, 0xc0, 0x0, + 0x0, 0x6, 0xff, 0x44, 0xfc, 0x0, 0x0, 0x0, + 0xa, 0xf9, 0x4f, 0xc0, 0x0, 0x0, 0x0, 0x7f, + 0xb4, 0xfc, 0x0, 0x0, 0x0, 0xb, 0xf9, 0x4f, + 0xc0, 0x0, 0x0, 0x29, 0xff, 0x34, 0xff, 0xee, + 0xee, 0xff, 0xff, 0x80, 0x4f, 0xff, 0xff, 0xff, + 0xea, 0x40, 0x4, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A3 "Σ" */ + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x6f, 0xfe, + 0xee, 0xee, 0xee, 0xe4, 0x2e, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xe2, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x1d, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xb0, 0x0, 0x0, 0x0, 0xa, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xe1, 0x0, 0x0, 0x0, + 0x5, 0xff, 0x30, 0x0, 0x0, 0x0, 0x2f, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfe, 0xee, 0xee, + 0xee, 0xea, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xfb, + + /* U+03A4 "Τ" */ + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xee, + 0xee, 0xff, 0xfe, 0xee, 0xed, 0x0, 0x0, 0x5, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xc0, 0x0, 0x0, + + /* U+03A5 "Υ" */ + 0x9f, 0xd0, 0x0, 0x0, 0x0, 0x4, 0xff, 0x20, + 0xef, 0x80, 0x0, 0x0, 0x0, 0xdf, 0x70, 0x4, + 0xff, 0x30, 0x0, 0x0, 0x8f, 0xc0, 0x0, 0xa, + 0xfd, 0x0, 0x0, 0x3f, 0xf2, 0x0, 0x0, 0x1e, + 0xf7, 0x0, 0xd, 0xf6, 0x0, 0x0, 0x0, 0x5f, + 0xf2, 0x7, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xb1, 0xff, 0x10, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xdf, 0x60, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xf3, 0x0, 0x0, 0x0, + + /* U+03A6 "Φ" */ + 0x0, 0x0, 0x0, 0x4, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5b, 0xdf, 0xff, 0xfd, 0x92, + 0x0, 0x0, 0x1, 0xcf, 0xfe, 0xdf, 0xfd, 0xff, + 0xf7, 0x0, 0x0, 0xcf, 0xc3, 0x4, 0xfd, 0x0, + 0x7f, 0xf6, 0x0, 0x6f, 0xd0, 0x0, 0x4f, 0xd0, + 0x0, 0x5f, 0xf1, 0xc, 0xf6, 0x0, 0x4, 0xfd, + 0x0, 0x0, 0xdf, 0x60, 0xff, 0x20, 0x0, 0x4f, + 0xd0, 0x0, 0x9, 0xf9, 0x1f, 0xf1, 0x0, 0x4, + 0xfd, 0x0, 0x0, 0x8f, 0x90, 0xff, 0x30, 0x0, + 0x4f, 0xd0, 0x0, 0x9, 0xf8, 0xc, 0xf7, 0x0, + 0x4, 0xfd, 0x0, 0x0, 0xdf, 0x40, 0x5f, 0xf2, + 0x0, 0x4f, 0xd0, 0x0, 0x8f, 0xd0, 0x0, 0xaf, + 0xf7, 0x24, 0xfd, 0x3, 0xaf, 0xf3, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xe3, 0x0, 0x0, + 0x0, 0x27, 0xad, 0xff, 0xb9, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x14, 0x30, 0x0, 0x0, + 0x0, + + /* U+03A7 "Χ" */ + 0xd, 0xfa, 0x0, 0x0, 0x0, 0x8, 0xfb, 0x0, + 0x2f, 0xf5, 0x0, 0x0, 0x4, 0xfe, 0x10, 0x0, + 0x6f, 0xe1, 0x0, 0x1, 0xef, 0x40, 0x0, 0x0, + 0xbf, 0xb0, 0x0, 0xcf, 0x80, 0x0, 0x0, 0x1, + 0xef, 0x60, 0x8f, 0xc0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0x5f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xaf, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0xdf, 0x70, 0xdf, + 0xa0, 0x0, 0x0, 0x0, 0x9f, 0xc0, 0x2, 0xff, + 0x50, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x7, 0xff, + 0x10, 0x0, 0x2f, 0xf5, 0x0, 0x0, 0xc, 0xfc, + 0x0, 0xc, 0xfa, 0x0, 0x0, 0x0, 0x2f, 0xf7, + 0x8, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x6f, 0xf3, + + /* U+03A8 "Ψ" */ + 0xaf, 0x70, 0x0, 0xd, 0xf3, 0x0, 0x1, 0xff, + 0xa, 0xf7, 0x0, 0x0, 0xdf, 0x30, 0x0, 0x1f, + 0xf0, 0xaf, 0x70, 0x0, 0xd, 0xf3, 0x0, 0x1, + 0xff, 0xa, 0xf7, 0x0, 0x0, 0xdf, 0x30, 0x0, + 0x1f, 0xf0, 0xaf, 0x70, 0x0, 0xd, 0xf3, 0x0, + 0x1, 0xff, 0x9, 0xf8, 0x0, 0x0, 0xdf, 0x30, + 0x0, 0x3f, 0xf0, 0x7f, 0xc0, 0x0, 0xd, 0xf3, + 0x0, 0x6, 0xfc, 0x2, 0xff, 0x30, 0x0, 0xdf, + 0x30, 0x0, 0xdf, 0x80, 0xa, 0xff, 0x71, 0xd, + 0xf3, 0x3, 0xcf, 0xe1, 0x0, 0xb, 0xff, 0xfd, + 0xff, 0xef, 0xff, 0xe3, 0x0, 0x0, 0x5, 0xae, + 0xff, 0xff, 0xec, 0x71, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0x30, 0x0, 0x0, 0x0, + + /* U+03A9 "Ω" */ + 0x0, 0x0, 0x7c, 0xef, 0xda, 0x40, 0x0, 0x0, + 0x3, 0xef, 0xfe, 0xdf, 0xff, 0x90, 0x0, 0x2, + 0xff, 0xc2, 0x0, 0x7, 0xff, 0x90, 0x0, 0xcf, + 0xb0, 0x0, 0x0, 0x4, 0xff, 0x40, 0x3f, 0xf2, + 0x0, 0x0, 0x0, 0xa, 0xfb, 0x8, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xf0, 0xaf, 0x70, 0x0, + 0x0, 0x0, 0x0, 0xff, 0x2c, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xf3, 0xaf, 0x70, 0x0, 0x0, + 0x0, 0x0, 0xff, 0x28, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xf0, 0x2f, 0xd0, 0x0, 0x0, 0x0, + 0x5, 0xfa, 0x0, 0xbf, 0x40, 0x0, 0x0, 0x0, + 0xcf, 0x20, 0x1, 0xee, 0x10, 0x0, 0x0, 0x7f, + 0x70, 0x0, 0x2, 0xed, 0x30, 0x0, 0x8f, 0x90, + 0x0, 0xde, 0xef, 0xff, 0x20, 0xaf, 0xfe, 0xee, + 0x6f, 0xff, 0xff, 0xf2, 0xb, 0xff, 0xff, 0xf6, + + /* U+03AA "Ϊ" */ + 0x4, 0x40, 0x4, 0x40, 0xf, 0xf0, 0xf, 0xf0, + 0xf, 0xf0, 0xf, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xf1, 0x0, 0x0, 0xf, 0xf1, 0x0, + 0x0, 0xf, 0xf1, 0x0, 0x0, 0xf, 0xf1, 0x0, + 0x0, 0xf, 0xf1, 0x0, 0x0, 0xf, 0xf1, 0x0, + 0x0, 0xf, 0xf1, 0x0, 0x0, 0xf, 0xf1, 0x0, + 0x0, 0xf, 0xf1, 0x0, 0x0, 0xf, 0xf1, 0x0, + 0x0, 0xf, 0xf1, 0x0, 0x0, 0xf, 0xf1, 0x0, + 0x0, 0xf, 0xf1, 0x0, 0x0, 0xf, 0xf1, 0x0, + 0x0, 0xf, 0xf1, 0x0, 0x0, 0xf, 0xf1, 0x0, + + /* U+03AB "Ϋ" */ + 0x0, 0x0, 0x34, 0x10, 0x34, 0x10, 0x0, 0x0, + 0x0, 0xb, 0xf4, 0xb, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0x40, 0xbf, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xd0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0x20, 0xef, 0x80, + 0x0, 0x0, 0x0, 0xdf, 0x70, 0x4, 0xff, 0x30, + 0x0, 0x0, 0x8f, 0xc0, 0x0, 0xa, 0xfd, 0x0, + 0x0, 0x3f, 0xf2, 0x0, 0x0, 0x1e, 0xf7, 0x0, + 0xd, 0xf6, 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x7, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xb1, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x1, 0xef, 0xdf, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xf3, 0x0, 0x0, 0x0, + + /* U+03AC "ά" */ + 0x0, 0x0, 0x0, 0xcf, 0x90, 0x0, 0x0, 0x0, + 0x4, 0xfc, 0x0, 0x0, 0x0, 0x0, 0xb, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xdf, 0xe8, 0x3, 0xfb, 0x0, 0xcf, + 0xfb, 0xcf, 0xb7, 0xf7, 0x7, 0xfe, 0x10, 0x3, + 0xff, 0xf3, 0xe, 0xf6, 0x0, 0x0, 0x8f, 0xf0, + 0x1f, 0xf1, 0x0, 0x0, 0x3f, 0xc0, 0x3f, 0xf0, + 0x0, 0x0, 0x1f, 0x90, 0x3f, 0xf0, 0x0, 0x0, + 0x2f, 0x90, 0x1f, 0xf1, 0x0, 0x0, 0x4f, 0xc0, + 0xd, 0xf5, 0x0, 0x0, 0xaf, 0xf0, 0x7, 0xfd, + 0x10, 0x4, 0xfe, 0xf3, 0x0, 0xcf, 0xea, 0xcf, + 0xb7, 0xf6, 0x0, 0x8, 0xdf, 0xe9, 0x2, 0xfb, + + /* U+03AD "έ" */ + 0x0, 0x1, 0xff, 0x50, 0x0, 0x0, 0x7f, 0x90, + 0x0, 0x0, 0xe, 0xc0, 0x0, 0x0, 0x0, 0x10, + 0x0, 0x0, 0x3, 0xbf, 0xfd, 0x70, 0x1, 0xef, + 0xdd, 0xff, 0x90, 0x7f, 0x80, 0x2, 0x80, 0x9, + 0xf4, 0x0, 0x0, 0x0, 0x5f, 0xd3, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0x50, 0x0, 0x2e, 0xfd, 0xb3, + 0x0, 0xb, 0xf8, 0x0, 0x0, 0x0, 0xef, 0x10, + 0x0, 0x0, 0xc, 0xf6, 0x0, 0xa, 0x80, 0x4f, + 0xfc, 0xbf, 0xfc, 0x10, 0x5c, 0xff, 0xc7, 0x0, + + /* U+03AE "ή" */ + 0x0, 0x0, 0xe, 0xf6, 0x0, 0x0, 0x0, 0x6f, + 0xa0, 0x0, 0x0, 0x0, 0xdd, 0x0, 0x0, 0x0, + 0x0, 0x10, 0x0, 0x0, 0x8f, 0x35, 0xcf, 0xeb, + 0x20, 0x8f, 0xaf, 0xec, 0xef, 0xf2, 0x8f, 0xf7, + 0x0, 0xc, 0xf8, 0x8f, 0xb0, 0x0, 0x5, 0xfb, + 0x8f, 0x80, 0x0, 0x3, 0xfc, 0x8f, 0x60, 0x0, + 0x2, 0xfc, 0x8f, 0x60, 0x0, 0x2, 0xfc, 0x8f, + 0x60, 0x0, 0x2, 0xfc, 0x8f, 0x60, 0x0, 0x2, + 0xfc, 0x8f, 0x60, 0x0, 0x2, 0xfc, 0x8f, 0x60, + 0x0, 0x2, 0xfc, 0x8f, 0x60, 0x0, 0x2, 0xfc, + 0x0, 0x0, 0x0, 0x2, 0xfc, 0x0, 0x0, 0x0, + 0x2, 0xfc, 0x0, 0x0, 0x0, 0x2, 0xfc, 0x0, + 0x0, 0x0, 0x2, 0xfc, + + /* U+03AF "ί" */ + 0xa, 0xfb, 0x2, 0xfe, 0x10, 0x9f, 0x30, 0x1, + 0x10, 0x0, 0x8f, 0x60, 0x8, 0xf6, 0x0, 0x8f, + 0x60, 0x8, 0xf6, 0x0, 0x8f, 0x60, 0x8, 0xf6, + 0x0, 0x8f, 0x60, 0x8, 0xf6, 0x0, 0x8f, 0x60, + 0x8, 0xf6, 0x0, 0x8f, 0x60, 0x8, 0xf6, 0x0, + + /* U+03B0 "ΰ" */ + 0xe, 0xf0, 0x3f, 0x9e, 0xf0, 0xe, 0xf0, 0xd9, + 0xe, 0xf0, 0x1, 0x10, 0x10, 0x1, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0x60, 0x0, 0x5, + 0xf9, 0x8f, 0x60, 0x0, 0x5, 0xf9, 0x8f, 0x60, + 0x0, 0x5, 0xf9, 0x8f, 0x60, 0x0, 0x5, 0xf9, + 0x8f, 0x60, 0x0, 0x5, 0xf9, 0x8f, 0x60, 0x0, + 0x5, 0xf9, 0x8f, 0x60, 0x0, 0x5, 0xf9, 0x7f, + 0x70, 0x0, 0x5, 0xf8, 0x6f, 0xa0, 0x0, 0x8, + 0xf6, 0x2f, 0xf3, 0x0, 0x3f, 0xf2, 0x7, 0xff, + 0xbb, 0xff, 0x80, 0x0, 0x5c, 0xff, 0xc5, 0x0, + + /* U+03B1 "α" */ + 0x0, 0x8, 0xdf, 0xe8, 0x3, 0xfb, 0x0, 0xcf, + 0xfb, 0xcf, 0xb7, 0xf7, 0x7, 0xfe, 0x10, 0x3, + 0xff, 0xf3, 0xe, 0xf6, 0x0, 0x0, 0x8f, 0xf0, + 0x1f, 0xf1, 0x0, 0x0, 0x3f, 0xc0, 0x3f, 0xf0, + 0x0, 0x0, 0x1f, 0x90, 0x3f, 0xf0, 0x0, 0x0, + 0x2f, 0x90, 0x1f, 0xf1, 0x0, 0x0, 0x4f, 0xc0, + 0xd, 0xf5, 0x0, 0x0, 0xaf, 0xf0, 0x7, 0xfd, + 0x10, 0x4, 0xfe, 0xf3, 0x0, 0xcf, 0xea, 0xcf, + 0xb7, 0xf6, 0x0, 0x8, 0xdf, 0xe9, 0x2, 0xfb, + + /* U+03B2 "β" */ + 0x0, 0x3a, 0xef, 0xe9, 0x10, 0x0, 0x6f, 0xfc, + 0xae, 0xfd, 0x10, 0x1f, 0xf3, 0x0, 0xa, 0xf8, + 0x5, 0xf9, 0x0, 0x0, 0x2f, 0xa0, 0x7f, 0x70, + 0x0, 0x5, 0xf7, 0x7, 0xf6, 0x1, 0x37, 0xfb, + 0x0, 0x8f, 0x60, 0xdf, 0xfa, 0x0, 0x8, 0xf6, + 0x4, 0x6a, 0xfe, 0x30, 0x8f, 0x60, 0x0, 0x4, + 0xfe, 0x18, 0xf6, 0x0, 0x0, 0xb, 0xf6, 0x8f, + 0x70, 0x0, 0x0, 0x7f, 0x98, 0xf8, 0x0, 0x0, + 0x6, 0xf9, 0x8f, 0xc0, 0x0, 0x0, 0x9f, 0x68, + 0xff, 0x60, 0x0, 0x3f, 0xf1, 0x8f, 0xbf, 0xb8, + 0x9f, 0xf6, 0x8, 0xf6, 0x4c, 0xff, 0xc4, 0x0, + 0x8f, 0x60, 0x0, 0x0, 0x0, 0x8, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0x60, 0x0, 0x0, 0x0, + 0x8, 0xf6, 0x0, 0x0, 0x0, 0x0, + + /* U+03B3 "γ" */ + 0x8f, 0x70, 0x0, 0x0, 0x6f, 0x83, 0xfd, 0x0, + 0x0, 0xc, 0xf2, 0xd, 0xf2, 0x0, 0x2, 0xfc, + 0x0, 0x7f, 0x80, 0x0, 0x8f, 0x70, 0x1, 0xfd, + 0x0, 0xd, 0xf1, 0x0, 0xb, 0xf3, 0x3, 0xfb, + 0x0, 0x0, 0x5f, 0x90, 0x9f, 0x50, 0x0, 0x0, + 0xfe, 0xe, 0xe0, 0x0, 0x0, 0x9, 0xf9, 0xf9, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0xef, 0xd0, 0x0, 0x0, 0x0, 0x8, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0x70, 0x0, 0x0, + 0x0, 0x8, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0x70, 0x0, 0x0, 0x0, 0x8, 0xf7, 0x0, 0x0, + + /* U+03B4 "δ" */ + 0x2, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0xdf, + 0xd9, 0x99, 0x99, 0x40, 0x0, 0x9, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5e, 0xa1, 0x0, 0x0, + 0x0, 0x7, 0xdf, 0xfe, 0x30, 0x0, 0x0, 0xbf, + 0xe9, 0x8d, 0xf6, 0x0, 0x7, 0xfd, 0x10, 0x0, + 0xaf, 0x50, 0xe, 0xf4, 0x0, 0x0, 0x1f, 0xe0, + 0x1f, 0xf0, 0x0, 0x0, 0xb, 0xf4, 0x3f, 0xc0, + 0x0, 0x0, 0x9, 0xf6, 0x2f, 0xd0, 0x0, 0x0, + 0x8, 0xf7, 0xf, 0xf0, 0x0, 0x0, 0xa, 0xf5, + 0xc, 0xf6, 0x0, 0x0, 0x1f, 0xf1, 0x5, 0xfe, + 0x20, 0x0, 0xbf, 0xa0, 0x0, 0x9f, 0xfb, 0xae, + 0xfd, 0x10, 0x0, 0x6, 0xcf, 0xfd, 0x70, 0x0, + + /* U+03B5 "ε" */ + 0x3, 0xbf, 0xfd, 0x70, 0x1, 0xef, 0xdd, 0xff, + 0x90, 0x7f, 0x80, 0x2, 0x80, 0x9, 0xf4, 0x0, + 0x0, 0x0, 0x5f, 0xd3, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0x50, 0x0, 0x2e, 0xfd, 0xb3, 0x0, 0xb, + 0xf8, 0x0, 0x0, 0x0, 0xef, 0x10, 0x0, 0x0, + 0xc, 0xf6, 0x0, 0xa, 0x80, 0x4f, 0xfc, 0xbf, + 0xfc, 0x10, 0x5c, 0xff, 0xc7, 0x0, + + /* U+03B6 "ζ" */ + 0x0, 0x7f, 0xff, 0xff, 0xf8, 0x0, 0x49, 0x99, + 0xbf, 0xe4, 0x0, 0x0, 0x3, 0xec, 0x10, 0x0, + 0x0, 0x4f, 0xb0, 0x0, 0x0, 0x3, 0xfb, 0x0, + 0x0, 0x0, 0x1e, 0xe1, 0x0, 0x0, 0x0, 0x9f, + 0x40, 0x0, 0x0, 0x3, 0xfb, 0x0, 0x0, 0x0, + 0x9, 0xf4, 0x0, 0x0, 0x0, 0xe, 0xe0, 0x0, + 0x0, 0x0, 0x2f, 0xc0, 0x0, 0x0, 0x0, 0x3f, + 0xc0, 0x0, 0x0, 0x0, 0x1f, 0xf1, 0x0, 0x0, + 0x0, 0xe, 0xfd, 0x63, 0x10, 0x0, 0x6, 0xff, + 0xff, 0xfe, 0x40, 0x0, 0x6d, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x2d, 0xf4, 0x0, 0x0, 0x0, + 0xb, 0xf1, 0x0, 0x0, 0x4, 0xcf, 0x80, 0x0, + 0x0, 0xb, 0xd7, 0x0, + + /* U+03B7 "η" */ + 0x8f, 0x35, 0xcf, 0xeb, 0x20, 0x8f, 0xaf, 0xec, + 0xef, 0xf2, 0x8f, 0xf7, 0x0, 0xc, 0xf8, 0x8f, + 0xb0, 0x0, 0x5, 0xfb, 0x8f, 0x80, 0x0, 0x3, + 0xfc, 0x8f, 0x60, 0x0, 0x2, 0xfc, 0x8f, 0x60, + 0x0, 0x2, 0xfc, 0x8f, 0x60, 0x0, 0x2, 0xfc, + 0x8f, 0x60, 0x0, 0x2, 0xfc, 0x8f, 0x60, 0x0, + 0x2, 0xfc, 0x8f, 0x60, 0x0, 0x2, 0xfc, 0x8f, + 0x60, 0x0, 0x2, 0xfc, 0x0, 0x0, 0x0, 0x2, + 0xfc, 0x0, 0x0, 0x0, 0x2, 0xfc, 0x0, 0x0, + 0x0, 0x2, 0xfc, 0x0, 0x0, 0x0, 0x2, 0xfc, + + /* U+03B8 "θ" */ + 0x0, 0x3, 0xbe, 0xfc, 0x60, 0x0, 0x0, 0x5f, + 0xfb, 0xbf, 0xf8, 0x0, 0x0, 0xef, 0x30, 0x1, + 0xdf, 0x30, 0x6, 0xf9, 0x0, 0x0, 0x5f, 0xa0, + 0xa, 0xf4, 0x0, 0x0, 0xf, 0xe0, 0xd, 0xf1, + 0x0, 0x0, 0xd, 0xf1, 0xf, 0xf0, 0x0, 0x0, + 0xc, 0xf3, 0xf, 0xff, 0xff, 0xff, 0xff, 0xf3, + 0xf, 0xf9, 0x99, 0x99, 0x9e, 0xf3, 0xf, 0xf0, + 0x0, 0x0, 0xc, 0xf3, 0xd, 0xf2, 0x0, 0x0, + 0xe, 0xf1, 0xa, 0xf5, 0x0, 0x0, 0x1f, 0xe0, + 0x6, 0xfa, 0x0, 0x0, 0x6f, 0xa0, 0x0, 0xef, + 0x40, 0x2, 0xef, 0x30, 0x0, 0x5f, 0xfb, 0xbf, + 0xf8, 0x0, 0x0, 0x3, 0xbf, 0xfc, 0x60, 0x0, + + /* U+03B9 "ι" */ + 0x8f, 0x68, 0xf6, 0x8f, 0x68, 0xf6, 0x8f, 0x68, + 0xf6, 0x8f, 0x68, 0xf6, 0x8f, 0x68, 0xf6, 0x8f, + 0x68, 0xf6, + + /* U+03BA "κ" */ + 0x9f, 0x50, 0x0, 0x7f, 0xe2, 0x9f, 0x50, 0x7, + 0xfe, 0x20, 0x9f, 0x50, 0x7f, 0xd1, 0x0, 0x9f, + 0x57, 0xfd, 0x10, 0x0, 0x9f, 0xbf, 0xd1, 0x0, + 0x0, 0x9f, 0xff, 0xd0, 0x0, 0x0, 0x9f, 0xdc, + 0xfa, 0x0, 0x0, 0x9f, 0x51, 0xef, 0x60, 0x0, + 0x9f, 0x50, 0x3f, 0xf3, 0x0, 0x9f, 0x50, 0x7, + 0xfe, 0x10, 0x9f, 0x50, 0x0, 0xaf, 0xc0, 0x9f, + 0x50, 0x0, 0xd, 0xf9, + + /* U+03BB "λ" */ + 0x0, 0xf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0x60, 0x0, 0x0, 0x0, 0x4, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0x70, 0x0, 0x0, 0x0, 0xd, 0xfd, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x9f, 0xcf, 0x90, 0x0, 0x0, 0xe, 0xf2, 0xfe, + 0x0, 0x0, 0x5, 0xfa, 0xb, 0xf5, 0x0, 0x0, + 0xbf, 0x40, 0x5f, 0xb0, 0x0, 0x1f, 0xe0, 0x0, + 0xef, 0x10, 0x7, 0xf9, 0x0, 0x9, 0xf6, 0x0, + 0xcf, 0x30, 0x0, 0x3f, 0xc0, 0x2f, 0xd0, 0x0, + 0x0, 0xdf, 0x28, 0xf7, 0x0, 0x0, 0x7, 0xf8, + + /* U+03BC "μ" */ + 0x8f, 0x60, 0x0, 0x3, 0xfb, 0x8f, 0x60, 0x0, + 0x3, 0xfb, 0x8f, 0x60, 0x0, 0x3, 0xfb, 0x8f, + 0x60, 0x0, 0x3, 0xfb, 0x8f, 0x60, 0x0, 0x3, + 0xfb, 0x8f, 0x60, 0x0, 0x3, 0xfb, 0x8f, 0x70, + 0x0, 0x3, 0xfb, 0x8f, 0x80, 0x0, 0x4, 0xfb, + 0x8f, 0xb0, 0x0, 0x8, 0xfb, 0x8f, 0xf6, 0x0, + 0x4f, 0xfb, 0x8f, 0xef, 0xee, 0xfd, 0xfb, 0x8f, + 0x78, 0xef, 0xb2, 0xfb, 0x8f, 0x60, 0x0, 0x0, + 0x0, 0x8f, 0x60, 0x0, 0x0, 0x0, 0x8f, 0x60, + 0x0, 0x0, 0x0, 0x8f, 0x60, 0x0, 0x0, 0x0, + + /* U+03BD "ν" */ + 0x8f, 0x70, 0x0, 0x0, 0x6f, 0x92, 0xfd, 0x0, + 0x0, 0xc, 0xf3, 0xd, 0xf2, 0x0, 0x1, 0xfd, + 0x0, 0x7f, 0x80, 0x0, 0x7f, 0x70, 0x1, 0xfd, + 0x0, 0xc, 0xf2, 0x0, 0xb, 0xf3, 0x2, 0xfc, + 0x0, 0x0, 0x5f, 0x80, 0x7f, 0x60, 0x0, 0x0, + 0xfd, 0xd, 0xf1, 0x0, 0x0, 0xa, 0xf5, 0xfa, + 0x0, 0x0, 0x0, 0x4f, 0xef, 0x50, 0x0, 0x0, + 0x0, 0xef, 0xe0, 0x0, 0x0, 0x0, 0x8, 0xf9, + 0x0, 0x0, + + /* U+03BE "ξ" */ + 0x0, 0x7, 0xcf, 0xff, 0x40, 0x0, 0xcf, 0xeb, + 0xaa, 0x30, 0x5, 0xfa, 0x0, 0x0, 0x0, 0x4, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xeb, 0xaa, + 0x10, 0x0, 0x4, 0xef, 0xff, 0x20, 0x0, 0x2d, + 0xf9, 0x30, 0x0, 0x1, 0xdf, 0x40, 0x0, 0x0, + 0x8, 0xf8, 0x0, 0x0, 0x0, 0xd, 0xf1, 0x0, + 0x0, 0x0, 0xf, 0xf0, 0x0, 0x0, 0x0, 0xe, + 0xf2, 0x0, 0x0, 0x0, 0xa, 0xfa, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xea, 0x73, 0x0, 0x0, 0x2b, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x3, 0x7e, 0xf3, + 0x0, 0x0, 0x0, 0x7, 0xf6, 0x0, 0x0, 0x0, + 0x1c, 0xf4, 0x0, 0x0, 0x7, 0xff, 0xb0, 0x0, + 0x0, 0xb, 0xd7, 0x0, + + /* U+03BF "ο" */ + 0x0, 0x5, 0xcf, 0xfd, 0x70, 0x0, 0x0, 0xaf, + 0xfb, 0xbe, 0xfc, 0x0, 0x6, 0xfd, 0x20, 0x0, + 0xbf, 0xa0, 0xd, 0xf4, 0x0, 0x0, 0x1f, 0xf1, + 0x1f, 0xe0, 0x0, 0x0, 0xb, 0xf5, 0x2f, 0xc0, + 0x0, 0x0, 0x9, 0xf7, 0x3f, 0xc0, 0x0, 0x0, + 0x9, 0xf6, 0x1f, 0xe0, 0x0, 0x0, 0xb, 0xf5, + 0xd, 0xf4, 0x0, 0x0, 0x1f, 0xf1, 0x6, 0xfd, + 0x20, 0x0, 0xbf, 0xa0, 0x0, 0xaf, 0xfb, 0xae, + 0xfd, 0x10, 0x0, 0x5, 0xcf, 0xfd, 0x70, 0x0, + + /* U+03C0 "π" */ + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb5, + 0xaa, 0xdf, 0xca, 0xaa, 0xae, 0xfa, 0xa7, 0x0, + 0x8, 0xf6, 0x0, 0x0, 0xdf, 0x10, 0x0, 0x0, + 0x8f, 0x60, 0x0, 0xd, 0xf1, 0x0, 0x0, 0x8, + 0xf6, 0x0, 0x0, 0xdf, 0x10, 0x0, 0x0, 0x8f, + 0x60, 0x0, 0xd, 0xf1, 0x0, 0x0, 0x8, 0xf6, + 0x0, 0x0, 0xdf, 0x10, 0x0, 0x0, 0x8f, 0x60, + 0x0, 0xd, 0xf1, 0x0, 0x0, 0x8, 0xf6, 0x0, + 0x0, 0xdf, 0x10, 0x0, 0x0, 0x8f, 0x60, 0x0, + 0xd, 0xf1, 0x0, 0x0, 0x8, 0xf6, 0x0, 0x0, + 0xdf, 0x10, 0x0, 0x0, 0x8f, 0x60, 0x0, 0xd, + 0xf1, 0x0, + + /* U+03C1 "ρ" */ + 0x0, 0x2a, 0xef, 0xe9, 0x10, 0x0, 0x3f, 0xfd, + 0xad, 0xfe, 0x20, 0xd, 0xf7, 0x0, 0x7, 0xfd, + 0x3, 0xfc, 0x0, 0x0, 0xb, 0xf5, 0x7f, 0x80, + 0x0, 0x0, 0x6f, 0x98, 0xf6, 0x0, 0x0, 0x4, + 0xfb, 0x9f, 0x60, 0x0, 0x0, 0x4f, 0xb9, 0xf7, + 0x0, 0x0, 0x6, 0xf9, 0x9f, 0xc0, 0x0, 0x0, + 0xcf, 0x59, 0xff, 0x60, 0x0, 0x6f, 0xd0, 0x9f, + 0xef, 0xca, 0xdf, 0xf3, 0x9, 0xf5, 0x7d, 0xfe, + 0xa2, 0x0, 0x9f, 0x50, 0x0, 0x0, 0x0, 0x9, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x9f, 0x50, 0x0, + 0x0, 0x0, 0x9, 0xf5, 0x0, 0x0, 0x0, 0x0, + + /* U+03C2 "ς" */ + 0x0, 0x0, 0x4a, 0xef, 0xfd, 0x30, 0x0, 0xbf, + 0xfc, 0xab, 0xe1, 0x0, 0xbf, 0xa1, 0x0, 0x0, + 0x0, 0x6f, 0xa0, 0x0, 0x0, 0x0, 0xc, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0x20, 0x0, 0x0, 0x0, 0x8, 0xfc, 0x10, 0x0, + 0x0, 0x0, 0xc, 0xff, 0x94, 0x0, 0x0, 0x0, + 0x7, 0xef, 0xff, 0x80, 0x0, 0x0, 0x0, 0x27, + 0xdf, 0x80, 0x0, 0x0, 0x0, 0x3, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xb0, 0x0, 0x0, 0x8d, + 0xff, 0xf3, 0x0, 0x0, 0xb, 0xfe, 0xa2, 0x0, + + /* U+03C3 "σ" */ + 0x0, 0x5, 0xcf, 0xff, 0xff, 0xff, 0xf1, 0x0, + 0xaf, 0xff, 0xff, 0xff, 0xee, 0xe1, 0x7, 0xfe, + 0x40, 0x3, 0xdf, 0x70, 0x0, 0xe, 0xf5, 0x0, + 0x0, 0x3f, 0xf0, 0x0, 0x2f, 0xe0, 0x0, 0x0, + 0xc, 0xf4, 0x0, 0x3f, 0xc0, 0x0, 0x0, 0xa, + 0xf6, 0x0, 0x3f, 0xb0, 0x0, 0x0, 0x9, 0xf6, + 0x0, 0x2f, 0xd0, 0x0, 0x0, 0xb, 0xf4, 0x0, + 0xe, 0xf2, 0x0, 0x0, 0x1f, 0xf1, 0x0, 0x7, + 0xfc, 0x10, 0x0, 0xbf, 0xa0, 0x0, 0x0, 0xaf, + 0xfb, 0xae, 0xfc, 0x10, 0x0, 0x0, 0x6, 0xcf, + 0xfc, 0x70, 0x0, 0x0, + + /* U+03C4 "τ" */ + 0x8f, 0xff, 0xff, 0xff, 0x35, 0xaa, 0xdf, 0xca, + 0xa1, 0x0, 0x8, 0xf7, 0x0, 0x0, 0x0, 0x8f, + 0x70, 0x0, 0x0, 0x8, 0xf7, 0x0, 0x0, 0x0, + 0x8f, 0x70, 0x0, 0x0, 0x8, 0xf7, 0x0, 0x0, + 0x0, 0x8f, 0x70, 0x0, 0x0, 0x8, 0xf7, 0x0, + 0x0, 0x0, 0x8f, 0x70, 0x0, 0x0, 0x8, 0xf7, + 0x0, 0x0, 0x0, 0x8f, 0x70, 0x0, + + /* U+03C5 "υ" */ + 0x8f, 0x60, 0x0, 0x5, 0xf9, 0x8f, 0x60, 0x0, + 0x5, 0xf9, 0x8f, 0x60, 0x0, 0x5, 0xf9, 0x8f, + 0x60, 0x0, 0x5, 0xf9, 0x8f, 0x60, 0x0, 0x5, + 0xf9, 0x8f, 0x60, 0x0, 0x5, 0xf9, 0x8f, 0x60, + 0x0, 0x5, 0xf9, 0x7f, 0x70, 0x0, 0x5, 0xf8, + 0x6f, 0xa0, 0x0, 0x8, 0xf6, 0x2f, 0xf3, 0x0, + 0x3f, 0xf2, 0x7, 0xff, 0xbb, 0xff, 0x80, 0x0, + 0x5c, 0xff, 0xc5, 0x0, + + /* U+03C6 "φ" */ + 0x0, 0x7, 0xd3, 0x1b, 0xfe, 0xa2, 0x0, 0x0, + 0xbf, 0xe0, 0x9f, 0xeb, 0xfe, 0x20, 0x7, 0xfc, + 0x0, 0xbf, 0x40, 0x5f, 0xb0, 0xe, 0xf2, 0x0, + 0xbf, 0x30, 0xc, 0xf2, 0x1f, 0xe0, 0x0, 0xcf, + 0x20, 0x9, 0xf6, 0x3f, 0xc0, 0x0, 0xcf, 0x20, + 0x9, 0xf7, 0x2f, 0xe0, 0x0, 0xcf, 0x20, 0xa, + 0xf6, 0xf, 0xf2, 0x0, 0xcf, 0x20, 0xe, 0xf2, + 0xa, 0xfa, 0x0, 0xcf, 0x20, 0x6f, 0xc0, 0x2, + 0xef, 0x80, 0xcf, 0x25, 0xff, 0x20, 0x0, 0x3e, + 0xff, 0xef, 0xef, 0xe4, 0x0, 0x0, 0x1, 0x9e, + 0xff, 0xe8, 0x10, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0x20, 0x0, 0x0, + + /* U+03C7 "χ" */ + 0x3f, 0xd0, 0x0, 0x0, 0x4f, 0xd0, 0xb, 0xf5, + 0x0, 0x0, 0xcf, 0x50, 0x3, 0xfd, 0x0, 0x4, + 0xfc, 0x0, 0x0, 0xbf, 0x50, 0xc, 0xf4, 0x0, + 0x0, 0x3f, 0xd0, 0x4f, 0xb0, 0x0, 0x0, 0xa, + 0xf5, 0xcf, 0x30, 0x0, 0x0, 0x2, 0xfe, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x4, + 0xfc, 0xfc, 0x0, 0x0, 0x0, 0xc, 0xf2, 0xaf, + 0x50, 0x0, 0x0, 0x5f, 0xa0, 0x2f, 0xd0, 0x0, + 0x0, 0xef, 0x20, 0xa, 0xf7, 0x0, 0x7, 0xf9, + 0x0, 0x2, 0xfe, 0x0, 0x1e, 0xf2, 0x0, 0x0, + 0x9f, 0x80, 0x8f, 0x90, 0x0, 0x0, 0x2f, 0xf1, + + /* U+03C8 "ψ" */ + 0xbf, 0x30, 0x2, 0xfd, 0x0, 0x9, 0xf5, 0xbf, + 0x30, 0x2, 0xfd, 0x0, 0x9, 0xf5, 0xbf, 0x30, + 0x2, 0xfd, 0x0, 0x9, 0xf5, 0xbf, 0x30, 0x2, + 0xfd, 0x0, 0x9, 0xf5, 0xbf, 0x30, 0x2, 0xfd, + 0x0, 0x9, 0xf5, 0xaf, 0x30, 0x2, 0xfd, 0x0, + 0x9, 0xf5, 0xaf, 0x40, 0x2, 0xfd, 0x0, 0x9, + 0xf5, 0x9f, 0x50, 0x2, 0xfd, 0x0, 0xa, 0xf4, + 0x7f, 0x90, 0x2, 0xfd, 0x0, 0xe, 0xf1, 0x1f, + 0xf5, 0x2, 0xfd, 0x0, 0xaf, 0xc0, 0x5, 0xff, + 0xdc, 0xff, 0xbf, 0xfd, 0x20, 0x0, 0x3a, 0xef, + 0xff, 0xec, 0x71, 0x0, 0x0, 0x0, 0x2, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xfd, 0x0, 0x0, 0x0, + + /* U+03C9 "ω" */ + 0x0, 0x9f, 0x40, 0x0, 0x0, 0x0, 0x1f, 0xc0, + 0x0, 0x1f, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0x40, 0x7, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xfa, 0x0, 0xbf, 0x40, 0x0, 0x6f, 0x80, 0x0, + 0x1f, 0xe0, 0xe, 0xf1, 0x0, 0x6, 0xf8, 0x0, + 0x0, 0xef, 0x10, 0xff, 0x0, 0x0, 0x6f, 0x80, + 0x0, 0xc, 0xf3, 0xf, 0xf0, 0x0, 0x6, 0xf8, + 0x0, 0x0, 0xcf, 0x30, 0xff, 0x0, 0x0, 0x6f, + 0x90, 0x0, 0xd, 0xf2, 0xc, 0xf4, 0x0, 0x9, + 0xfc, 0x0, 0x1, 0xff, 0x0, 0x6f, 0xc0, 0x2, + 0xec, 0xf4, 0x0, 0x9f, 0x90, 0x0, 0xcf, 0xc9, + 0xee, 0x1c, 0xfa, 0xbf, 0xe1, 0x0, 0x1, 0x9e, + 0xfb, 0x20, 0x9, 0xef, 0xb2, 0x0, + + /* U+03CA "ϊ" */ + 0x9f, 0x60, 0x9f, 0x79, 0xf6, 0x9, 0xf7, 0x24, + 0x10, 0x24, 0x10, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0x60, 0x0, 0x8, 0xf6, 0x0, 0x0, 0x8f, 0x60, + 0x0, 0x8, 0xf6, 0x0, 0x0, 0x8f, 0x60, 0x0, + 0x8, 0xf6, 0x0, 0x0, 0x8f, 0x60, 0x0, 0x8, + 0xf6, 0x0, 0x0, 0x8f, 0x60, 0x0, 0x8, 0xf6, + 0x0, 0x0, 0x8f, 0x60, 0x0, 0x8, 0xf6, 0x0, + + /* U+03CB "ϋ" */ + 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0xff, 0x0, + 0xff, 0x0, 0x0, 0x44, 0x0, 0x44, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0x60, 0x0, 0x5, + 0xf9, 0x8f, 0x60, 0x0, 0x5, 0xf9, 0x8f, 0x60, + 0x0, 0x5, 0xf9, 0x8f, 0x60, 0x0, 0x5, 0xf9, + 0x8f, 0x60, 0x0, 0x5, 0xf9, 0x8f, 0x60, 0x0, + 0x5, 0xf9, 0x8f, 0x60, 0x0, 0x5, 0xf9, 0x7f, + 0x70, 0x0, 0x5, 0xf8, 0x6f, 0xa0, 0x0, 0x8, + 0xf6, 0x2f, 0xf3, 0x0, 0x3f, 0xf2, 0x7, 0xff, + 0xbb, 0xff, 0x80, 0x0, 0x5c, 0xff, 0xc5, 0x0, + + /* U+03CC "ό" */ + 0x0, 0x0, 0x0, 0xef, 0x60, 0x0, 0x0, 0x0, + 0x6, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xd, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xcf, 0xfd, 0x70, 0x0, 0x0, 0xaf, + 0xfb, 0xbe, 0xfc, 0x0, 0x6, 0xfd, 0x20, 0x0, + 0xbf, 0xa0, 0xd, 0xf4, 0x0, 0x0, 0x1f, 0xf1, + 0x1f, 0xe0, 0x0, 0x0, 0xb, 0xf5, 0x2f, 0xc0, + 0x0, 0x0, 0x9, 0xf7, 0x3f, 0xc0, 0x0, 0x0, + 0x9, 0xf6, 0x1f, 0xe0, 0x0, 0x0, 0xb, 0xf5, + 0xd, 0xf4, 0x0, 0x0, 0x1f, 0xf1, 0x6, 0xfd, + 0x20, 0x0, 0xbf, 0xa0, 0x0, 0xaf, 0xfb, 0xae, + 0xfd, 0x10, 0x0, 0x5, 0xcf, 0xfd, 0x70, 0x0, + + /* U+03CD "ύ" */ + 0x0, 0x0, 0x1f, 0xf5, 0x0, 0x0, 0x0, 0x8f, + 0x90, 0x0, 0x0, 0x0, 0xec, 0x0, 0x0, 0x0, + 0x0, 0x10, 0x0, 0x0, 0x8f, 0x60, 0x0, 0x5, + 0xf9, 0x8f, 0x60, 0x0, 0x5, 0xf9, 0x8f, 0x60, + 0x0, 0x5, 0xf9, 0x8f, 0x60, 0x0, 0x5, 0xf9, + 0x8f, 0x60, 0x0, 0x5, 0xf9, 0x8f, 0x60, 0x0, + 0x5, 0xf9, 0x8f, 0x60, 0x0, 0x5, 0xf9, 0x7f, + 0x70, 0x0, 0x5, 0xf8, 0x6f, 0xa0, 0x0, 0x8, + 0xf6, 0x2f, 0xf3, 0x0, 0x3f, 0xf2, 0x7, 0xff, + 0xbb, 0xff, 0x80, 0x0, 0x5c, 0xff, 0xc5, 0x0, + + /* U+03CE "ώ" */ + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0x40, 0x0, 0x0, 0x0, + 0x1f, 0xc0, 0x0, 0x1f, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0x40, 0x7, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xfa, 0x0, 0xbf, 0x40, 0x0, 0x6f, + 0x80, 0x0, 0x1f, 0xe0, 0xe, 0xf1, 0x0, 0x6, + 0xf8, 0x0, 0x0, 0xef, 0x10, 0xff, 0x0, 0x0, + 0x6f, 0x80, 0x0, 0xc, 0xf3, 0xf, 0xf0, 0x0, + 0x6, 0xf8, 0x0, 0x0, 0xcf, 0x30, 0xff, 0x0, + 0x0, 0x6f, 0x90, 0x0, 0xd, 0xf2, 0xc, 0xf4, + 0x0, 0x9, 0xfc, 0x0, 0x1, 0xff, 0x0, 0x6f, + 0xc0, 0x2, 0xec, 0xf4, 0x0, 0x9f, 0x90, 0x0, + 0xcf, 0xc9, 0xee, 0x1c, 0xfa, 0xbf, 0xe1, 0x0, + 0x1, 0x9e, 0xfb, 0x20, 0x9, 0xef, 0xb2, 0x0, + + /* U+03F4 "ϴ" */ + 0x3f, 0xa0, 0x9f, 0x8f, 0x93, 0xfa, 0x4f, 0x44, + 0xf9, 0x2, 0x11, 0x10, 0x2, 0x10 +}; + + +/*--------------------- + * GLYPH DESCRIPTION + *--------------------*/ + +static const lv_font_fmt_txt_glyph_dsc_t glyph_dsc[] = { + {.bitmap_index = 0, .adv_w = 0, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0} /* id = 0 reserved */, + {.bitmap_index = 0, .adv_w = 98, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 0, .adv_w = 98, .box_w = 4, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 32, .adv_w = 125, .box_w = 6, .box_h = 6, .ofs_x = 1, .ofs_y = 10}, + {.bitmap_index = 50, .adv_w = 196, .box_w = 12, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 146, .adv_w = 196, .box_w = 12, .box_h = 20, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 266, .adv_w = 313, .box_w = 18, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 410, .adv_w = 235, .box_w = 15, .box_h = 17, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 538, .adv_w = 67, .box_w = 3, .box_h = 6, .ofs_x = 1, .ofs_y = 10}, + {.bitmap_index = 547, .adv_w = 117, .box_w = 6, .box_h = 20, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 607, .adv_w = 117, .box_w = 6, .box_h = 20, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 667, .adv_w = 137, .box_w = 8, .box_h = 7, .ofs_x = 0, .ofs_y = 9}, + {.bitmap_index = 695, .adv_w = 206, .box_w = 11, .box_h = 11, .ofs_x = 1, .ofs_y = 3}, + {.bitmap_index = 756, .adv_w = 98, .box_w = 4, .box_h = 7, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 770, .adv_w = 117, .box_w = 7, .box_h = 2, .ofs_x = 0, .ofs_y = 5}, + {.bitmap_index = 777, .adv_w = 98, .box_w = 4, .box_h = 3, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 783, .adv_w = 98, .box_w = 7, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 839, .adv_w = 196, .box_w = 12, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 935, .adv_w = 196, .box_w = 7, .box_h = 16, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 991, .adv_w = 196, .box_w = 12, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1087, .adv_w = 196, .box_w = 12, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1183, .adv_w = 196, .box_w = 12, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1279, .adv_w = 196, .box_w = 12, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1375, .adv_w = 196, .box_w = 12, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1471, .adv_w = 196, .box_w = 11, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1559, .adv_w = 196, .box_w = 12, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1655, .adv_w = 196, .box_w = 12, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1751, .adv_w = 98, .box_w = 4, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1775, .adv_w = 98, .box_w = 4, .box_h = 16, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 1807, .adv_w = 206, .box_w = 11, .box_h = 12, .ofs_x = 1, .ofs_y = 2}, + {.bitmap_index = 1873, .adv_w = 206, .box_w = 11, .box_h = 7, .ofs_x = 1, .ofs_y = 5}, + {.bitmap_index = 1912, .adv_w = 206, .box_w = 11, .box_h = 12, .ofs_x = 1, .ofs_y = 2}, + {.bitmap_index = 1978, .adv_w = 196, .box_w = 11, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2066, .adv_w = 357, .box_w = 21, .box_h = 20, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 2276, .adv_w = 235, .box_w = 16, .box_h = 16, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 2404, .adv_w = 235, .box_w = 13, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2508, .adv_w = 254, .box_w = 15, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2628, .adv_w = 254, .box_w = 14, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2740, .adv_w = 235, .box_w = 13, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2844, .adv_w = 216, .box_w = 12, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2940, .adv_w = 274, .box_w = 15, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3060, .adv_w = 254, .box_w = 14, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3172, .adv_w = 98, .box_w = 3, .box_h = 16, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 3196, .adv_w = 176, .box_w = 10, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3276, .adv_w = 235, .box_w = 14, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3388, .adv_w = 196, .box_w = 11, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3476, .adv_w = 293, .box_w = 16, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3604, .adv_w = 254, .box_w = 14, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3716, .adv_w = 274, .box_w = 16, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3844, .adv_w = 235, .box_w = 13, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3948, .adv_w = 274, .box_w = 16, .box_h = 17, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 4084, .adv_w = 254, .box_w = 15, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4204, .adv_w = 235, .box_w = 14, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4316, .adv_w = 216, .box_w = 13, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4420, .adv_w = 254, .box_w = 14, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4532, .adv_w = 235, .box_w = 15, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4652, .adv_w = 332, .box_w = 21, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4820, .adv_w = 235, .box_w = 15, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4940, .adv_w = 235, .box_w = 15, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5060, .adv_w = 216, .box_w = 13, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5164, .adv_w = 98, .box_w = 5, .box_h = 20, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 5214, .adv_w = 98, .box_w = 7, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5270, .adv_w = 98, .box_w = 5, .box_h = 20, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 5320, .adv_w = 165, .box_w = 10, .box_h = 9, .ofs_x = 0, .ofs_y = 8}, + {.bitmap_index = 5365, .adv_w = 196, .box_w = 14, .box_h = 3, .ofs_x = -1, .ofs_y = -5}, + {.bitmap_index = 5386, .adv_w = 117, .box_w = 5, .box_h = 4, .ofs_x = 0, .ofs_y = 13}, + {.bitmap_index = 5396, .adv_w = 196, .box_w = 12, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5468, .adv_w = 196, .box_w = 11, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 5556, .adv_w = 176, .box_w = 11, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5622, .adv_w = 196, .box_w = 11, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5710, .adv_w = 196, .box_w = 12, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5782, .adv_w = 98, .box_w = 7, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5838, .adv_w = 196, .box_w = 11, .box_h = 16, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 5926, .adv_w = 196, .box_w = 10, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 6006, .adv_w = 78, .box_w = 3, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 6030, .adv_w = 78, .box_w = 5, .box_h = 20, .ofs_x = -1, .ofs_y = -4}, + {.bitmap_index = 6080, .adv_w = 176, .box_w = 10, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 6160, .adv_w = 78, .box_w = 3, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 6184, .adv_w = 293, .box_w = 16, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 6280, .adv_w = 196, .box_w = 10, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 6340, .adv_w = 196, .box_w = 12, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6412, .adv_w = 196, .box_w = 11, .box_h = 16, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 6500, .adv_w = 196, .box_w = 11, .box_h = 16, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 6588, .adv_w = 117, .box_w = 7, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 6630, .adv_w = 176, .box_w = 11, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6696, .adv_w = 98, .box_w = 6, .box_h = 17, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6747, .adv_w = 196, .box_w = 10, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 6807, .adv_w = 176, .box_w = 11, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6873, .adv_w = 254, .box_w = 16, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6969, .adv_w = 176, .box_w = 11, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7035, .adv_w = 176, .box_w = 11, .box_h = 16, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 7123, .adv_w = 176, .box_w = 11, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7189, .adv_w = 117, .box_w = 7, .box_h = 20, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 7259, .adv_w = 91, .box_w = 2, .box_h = 20, .ofs_x = 2, .ofs_y = -4}, + {.bitmap_index = 7279, .adv_w = 117, .box_w = 7, .box_h = 20, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 7349, .adv_w = 206, .box_w = 12, .box_h = 6, .ofs_x = 0, .ofs_y = 5}, + {.bitmap_index = 7385, .adv_w = 98, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7385, .adv_w = 196, .box_w = 12, .box_h = 17, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 7487, .adv_w = 196, .box_w = 12, .box_h = 11, .ofs_x = 0, .ofs_y = 2}, + {.bitmap_index = 7553, .adv_w = 196, .box_w = 13, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7657, .adv_w = 92, .box_w = 2, .box_h = 20, .ofs_x = 2, .ofs_y = -4}, + {.bitmap_index = 7677, .adv_w = 196, .box_w = 12, .box_h = 20, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 7797, .adv_w = 117, .box_w = 7, .box_h = 3, .ofs_x = 0, .ofs_y = 14}, + {.bitmap_index = 7808, .adv_w = 259, .box_w = 17, .box_h = 18, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 7961, .adv_w = 132, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 8}, + {.bitmap_index = 7993, .adv_w = 196, .box_w = 10, .box_h = 11, .ofs_x = 1, .ofs_y = 1}, + {.bitmap_index = 8048, .adv_w = 206, .box_w = 11, .box_h = 7, .ofs_x = 1, .ofs_y = 5}, + {.bitmap_index = 8087, .adv_w = 117, .box_w = 7, .box_h = 2, .ofs_x = 0, .ofs_y = 5}, + {.bitmap_index = 8094, .adv_w = 259, .box_w = 17, .box_h = 18, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 8247, .adv_w = 141, .box_w = 7, .box_h = 7, .ofs_x = 1, .ofs_y = 10}, + {.bitmap_index = 8272, .adv_w = 206, .box_w = 11, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 8349, .adv_w = 117, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 8}, + {.bitmap_index = 8377, .adv_w = 117, .box_w = 7, .box_h = 8, .ofs_x = 0, .ofs_y = 8}, + {.bitmap_index = 8405, .adv_w = 196, .box_w = 10, .box_h = 16, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 8485, .adv_w = 189, .box_w = 13, .box_h = 20, .ofs_x = -1, .ofs_y = -4}, + {.bitmap_index = 8615, .adv_w = 99, .box_w = 4, .box_h = 3, .ofs_x = 1, .ofs_y = 7}, + {.bitmap_index = 8621, .adv_w = 196, .box_w = 10, .box_h = 11, .ofs_x = 1, .ofs_y = 1}, + {.bitmap_index = 8676, .adv_w = 294, .box_w = 17, .box_h = 18, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 8829, .adv_w = 117, .box_w = 5, .box_h = 4, .ofs_x = 2, .ofs_y = 14}, + {.bitmap_index = 8839, .adv_w = 235, .box_w = 16, .box_h = 16, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 8967, .adv_w = 276, .box_w = 18, .box_h = 16, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 9111, .adv_w = 295, .box_w = 18, .box_h = 16, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 9255, .adv_w = 135, .box_w = 7, .box_h = 16, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 9311, .adv_w = 273, .box_w = 17, .box_h = 16, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 9447, .adv_w = 301, .box_w = 20, .box_h = 16, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 9607, .adv_w = 265, .box_w = 17, .box_h = 16, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 9743, .adv_w = 78, .box_w = 9, .box_h = 16, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 9815, .adv_w = 235, .box_w = 16, .box_h = 16, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 9943, .adv_w = 235, .box_w = 13, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 10047, .adv_w = 194, .box_w = 11, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 10135, .adv_w = 235, .box_w = 16, .box_h = 16, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 10263, .adv_w = 235, .box_w = 13, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 10367, .adv_w = 216, .box_w = 13, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 10471, .adv_w = 254, .box_w = 14, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 10583, .adv_w = 274, .box_w = 16, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 10711, .adv_w = 98, .box_w = 3, .box_h = 16, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 10735, .adv_w = 235, .box_w = 14, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 10847, .adv_w = 235, .box_w = 15, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 10967, .adv_w = 293, .box_w = 16, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 11095, .adv_w = 254, .box_w = 14, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 11207, .adv_w = 229, .box_w = 13, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 11311, .adv_w = 274, .box_w = 16, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 11439, .adv_w = 254, .box_w = 14, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 11551, .adv_w = 235, .box_w = 13, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 11655, .adv_w = 218, .box_w = 12, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 11751, .adv_w = 216, .box_w = 13, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 11855, .adv_w = 235, .box_w = 15, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 11975, .adv_w = 281, .box_w = 17, .box_h = 18, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 12128, .adv_w = 235, .box_w = 15, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 12248, .adv_w = 294, .box_w = 17, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 12384, .adv_w = 263, .box_w = 15, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 12504, .adv_w = 98, .box_w = 8, .box_h = 20, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 12584, .adv_w = 235, .box_w = 15, .box_h = 20, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 12734, .adv_w = 204, .box_w = 12, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 12830, .adv_w = 157, .box_w = 9, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 12902, .adv_w = 196, .box_w = 10, .box_h = 20, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 13002, .adv_w = 78, .box_w = 5, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 13042, .adv_w = 193, .box_w = 10, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 13122, .adv_w = 204, .box_w = 12, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 13194, .adv_w = 202, .box_w = 11, .box_h = 20, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 13304, .adv_w = 176, .box_w = 11, .box_h = 16, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 13392, .adv_w = 196, .box_w = 12, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 13488, .adv_w = 157, .box_w = 9, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 13542, .adv_w = 155, .box_w = 10, .box_h = 20, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 13642, .adv_w = 196, .box_w = 10, .box_h = 16, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 13722, .adv_w = 196, .box_w = 12, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 13818, .adv_w = 78, .box_w = 3, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 13836, .adv_w = 175, .box_w = 10, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 13896, .adv_w = 176, .box_w = 11, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 13984, .adv_w = 196, .box_w = 10, .box_h = 16, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 14064, .adv_w = 176, .box_w = 11, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 14130, .adv_w = 158, .box_w = 10, .box_h = 20, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 14230, .adv_w = 196, .box_w = 12, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 14302, .adv_w = 243, .box_w = 15, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 14392, .adv_w = 200, .box_w = 11, .box_h = 16, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 14480, .adv_w = 170, .box_w = 11, .box_h = 16, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 14568, .adv_w = 217, .box_w = 14, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 14652, .adv_w = 139, .box_w = 9, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 14706, .adv_w = 193, .box_w = 10, .box_h = 12, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 14766, .adv_w = 228, .box_w = 14, .box_h = 16, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 14878, .adv_w = 185, .box_w = 12, .box_h = 16, .ofs_x = 0, .ofs_y = -4}, + {.bitmap_index = 14974, .adv_w = 251, .box_w = 14, .box_h = 16, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 15086, .adv_w = 275, .box_w = 17, .box_h = 12, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 15188, .adv_w = 78, .box_w = 7, .box_h = 16, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 15244, .adv_w = 193, .box_w = 10, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 15324, .adv_w = 196, .box_w = 12, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 15420, .adv_w = 193, .box_w = 10, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 15500, .adv_w = 275, .box_w = 17, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 15636, .adv_w = 117, .box_w = 9, .box_h = 3, .ofs_x = -1, .ofs_y = 13} +}; + +/*--------------------- + * CHARACTER MAPPING + *--------------------*/ + +static const uint8_t glyph_id_ofs_list_1[] = { + 0, 0, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 0, + 13, 14, 15, 16, 0, 17, 18, 19, + 0, 0, 0, 20, 0, 21 +}; + +static const uint8_t glyph_id_ofs_list_2[] = { + 0, 0, 1, 0, 2, 3, 4, 0, + 5 +}; + +/*Collect the unicode lists and glyph_id offsets*/ +static const lv_font_fmt_txt_cmap_t cmaps[] = +{ + { + .range_start = 32, .range_length = 95, .glyph_id_start = 1, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 160, .range_length = 30, .glyph_id_start = 96, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_1, .list_length = 30, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 900, .range_length = 9, .glyph_id_start = 118, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_2, .list_length = 9, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 910, .range_length = 20, .glyph_id_start = 124, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 931, .range_length = 44, .glyph_id_start = 144, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 1012, .range_length = 1, .glyph_id_start = 188, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + } +}; + + + +/*-------------------- + * ALL CUSTOM DATA + *--------------------*/ + +#if LVGL_VERSION_MAJOR == 8 +/*Store all the custom data of the font*/ +static lv_font_fmt_txt_glyph_cache_t cache; +#endif + +#if LVGL_VERSION_MAJOR >= 8 +static const lv_font_fmt_txt_dsc_t font_dsc = { +#else +static lv_font_fmt_txt_dsc_t font_dsc = { +#endif + .glyph_bitmap = glyph_bitmap, + .glyph_dsc = glyph_dsc, + .cmaps = cmaps, + .kern_dsc = NULL, + .kern_scale = 0, + .cmap_num = 6, + .bpp = 4, + .kern_classes = 0, + .bitmap_format = 0, +#if LVGL_VERSION_MAJOR == 8 + .cache = &cache +#endif + +}; + +extern const lv_font_t lv_font_montserrat_22; + + +/*----------------- + * PUBLIC FONT + *----------------*/ + +/*Initialize a public general font descriptor*/ +#if LVGL_VERSION_MAJOR >= 8 +const lv_font_t lv_font_arial_22 = { +#else +lv_font_t lv_font_arial_22 = { +#endif + .get_glyph_dsc = lv_font_get_glyph_dsc_fmt_txt, /*Function pointer to get glyph's data*/ + .get_glyph_bitmap = lv_font_get_bitmap_fmt_txt, /*Function pointer to get glyph's bitmap*/ + .line_height = 25, /*The maximum line height required by the font*/ + .base_line = 5, /*Baseline measured from the bottom of the line*/ +#if !(LVGL_VERSION_MAJOR == 6 && LVGL_VERSION_MINOR == 0) + .subpx = LV_FONT_SUBPX_NONE, +#endif +#if LV_VERSION_CHECK(7, 4, 0) || LVGL_VERSION_MAJOR >= 8 + .underline_position = -2, + .underline_thickness = 2, +#endif + //.static_bitmap = 0, + .dsc = &font_dsc, /*The custom font data. Will be accessed by `get_glyph_bitmap/dsc` */ +#if LV_VERSION_CHECK(8, 2, 0) || LVGL_VERSION_MAJOR >= 9 + .fallback = &lv_font_montserrat_22, +#endif + .user_data = NULL, +}; + + + +#endif /*#if LV_FONT_ARIAL_22*/ diff --git a/src/fonts/lv_font_arial_24.c b/src/fonts/lv_font_arial_24.c new file mode 100644 index 0000000000..6dcdac1ecd --- /dev/null +++ b/src/fonts/lv_font_arial_24.c @@ -0,0 +1,3159 @@ +/******************************************************************************* + * Size: 24 px + * Bpp: 4 + * Opts: --bpp 4 --size 24 --no-compress --stride 1 --align 1 --font Arial Greek Regular.ttf --range 32-127,160-255,880-1023 --format lvgl -o lv_font_arial_24.c + ******************************************************************************/ + +#ifdef __has_include + #if __has_include("lvgl.h") + #ifndef LV_LVGL_H_INCLUDE_SIMPLE + #define LV_LVGL_H_INCLUDE_SIMPLE + #endif + #endif +#endif + +#ifdef LV_LVGL_H_INCLUDE_SIMPLE + #include "lvgl.h" +#else + #include "lvgl/lvgl.h" +#endif + + + +#ifndef LV_FONT_ARIAL_24 +#define LV_FONT_ARIAL_24 1 +#endif + +#if LV_FONT_ARIAL_24 + +/*----------------- + * BITMAPS + *----------------*/ + +/*Store the image of the glyphs*/ +static LV_ATTRIBUTE_LARGE_CONST const uint8_t glyph_bitmap[] = { + /* U+0020 " " */ + + /* U+0021 "!" */ + 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xef, 0x9d, + 0xf8, 0xcf, 0x7b, 0xf6, 0xaf, 0x59, 0xf4, 0x8f, + 0x37, 0xf2, 0x6f, 0x10, 0x20, 0x0, 0x6, 0x73, + 0xef, 0x8e, 0xf8, + + /* U+0022 "\"" */ + 0xef, 0x80, 0xff, 0x6e, 0xf8, 0xf, 0xf6, 0xef, + 0x80, 0xff, 0x6c, 0xf6, 0xe, 0xf4, 0x9f, 0x40, + 0xbf, 0x26, 0xf1, 0x8, 0xf0, 0x13, 0x0, 0x12, + 0x0, + + /* U+0023 "#" */ + 0x0, 0x0, 0x3f, 0x80, 0x0, 0xcf, 0x0, 0x0, + 0x0, 0x7f, 0x50, 0x0, 0xfc, 0x0, 0x0, 0x0, + 0xaf, 0x10, 0x3, 0xf9, 0x0, 0x0, 0x0, 0xde, + 0x0, 0x6, 0xf5, 0x0, 0x0, 0x0, 0xfb, 0x0, + 0x9, 0xf2, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf1, 0x8c, 0xce, 0xfd, 0xcc, 0xcf, 0xec, + 0xc1, 0x0, 0xa, 0xf1, 0x0, 0x3f, 0x90, 0x0, + 0x0, 0xd, 0xe0, 0x0, 0x6f, 0x50, 0x0, 0x0, + 0xf, 0xb0, 0x0, 0x9f, 0x20, 0x0, 0x0, 0x3f, + 0x80, 0x0, 0xcf, 0x0, 0x0, 0x8c, 0xdf, 0xdc, + 0xcc, 0xff, 0xcc, 0xc1, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf1, 0x0, 0xde, 0x0, 0x6, 0xf6, + 0x0, 0x0, 0x0, 0xfb, 0x0, 0x9, 0xf2, 0x0, + 0x0, 0x3, 0xf8, 0x0, 0xc, 0xf0, 0x0, 0x0, + 0x7, 0xf5, 0x0, 0xf, 0xc0, 0x0, 0x0, 0xa, + 0xf1, 0x0, 0x3f, 0x90, 0x0, 0x0, + + /* U+0024 "$" */ + 0x0, 0x0, 0x0, 0x72, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x6f, 0x82, 0x0, 0x0, 0x0, 0x1b, 0xff, + 0xff, 0xfc, 0x20, 0x0, 0xc, 0xfe, 0x7f, 0x9d, + 0xfd, 0x0, 0x5, 0xfe, 0x10, 0xf4, 0x1e, 0xf7, + 0x0, 0xaf, 0x80, 0xf, 0x40, 0x8f, 0xa0, 0xb, + 0xf6, 0x0, 0xf4, 0x0, 0x10, 0x0, 0x9f, 0xa0, + 0xf, 0x40, 0x0, 0x0, 0x4, 0xff, 0x70, 0xf4, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xef, 0x81, 0x0, + 0x0, 0x0, 0x6, 0xef, 0xff, 0xfa, 0x10, 0x0, + 0x0, 0x0, 0x3f, 0xdf, 0xfe, 0x20, 0x0, 0x0, + 0x0, 0xf4, 0x2d, 0xfc, 0x0, 0x0, 0x0, 0xf, + 0x40, 0x3f, 0xf1, 0x4, 0x70, 0x0, 0xf4, 0x0, + 0xff, 0x30, 0xff, 0x40, 0xf, 0x40, 0xf, 0xf3, + 0xc, 0xfa, 0x0, 0xf4, 0x5, 0xff, 0x0, 0x5f, + 0xf7, 0xf, 0x44, 0xef, 0x80, 0x0, 0x9f, 0xfe, + 0xfe, 0xff, 0xc0, 0x0, 0x0, 0x4b, 0xff, 0xfd, + 0x70, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0x40, 0x0, 0x0, + + /* U+0025 "%" */ + 0x1, 0xaf, 0xfb, 0x20, 0x0, 0x0, 0xb, 0xe0, + 0x0, 0x0, 0xcf, 0xa9, 0xfe, 0x10, 0x0, 0x4, + 0xf7, 0x0, 0x0, 0x4f, 0x90, 0x5, 0xf8, 0x0, + 0x0, 0xce, 0x0, 0x0, 0x7, 0xf5, 0x0, 0x1f, + 0xb0, 0x0, 0x5f, 0x60, 0x0, 0x0, 0x8f, 0x40, + 0x1, 0xfc, 0x0, 0xd, 0xd0, 0x0, 0x0, 0x6, + 0xf7, 0x0, 0x4f, 0xa0, 0x5, 0xf5, 0x0, 0x0, + 0x0, 0x1f, 0xe4, 0x3c, 0xf4, 0x0, 0xdd, 0x0, + 0x0, 0x0, 0x0, 0x4e, 0xff, 0xf6, 0x0, 0x6f, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x4, 0x41, 0x0, + 0xe, 0xc0, 0x0, 0x11, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xf4, 0x1, 0xbf, 0xfe, 0x40, 0x0, + 0x0, 0x0, 0x0, 0xec, 0x0, 0xaf, 0x96, 0xdf, + 0x20, 0x0, 0x0, 0x0, 0x7f, 0x40, 0x2f, 0xb0, + 0x3, 0xf9, 0x0, 0x0, 0x0, 0x1f, 0xb0, 0x5, + 0xf7, 0x0, 0xf, 0xc0, 0x0, 0x0, 0x8, 0xf3, + 0x0, 0x6f, 0x60, 0x0, 0xfe, 0x0, 0x0, 0x1, + 0xfb, 0x0, 0x5, 0xf7, 0x0, 0xf, 0xd0, 0x0, + 0x0, 0x9f, 0x20, 0x0, 0x2f, 0xc0, 0x5, 0xf9, + 0x0, 0x0, 0x1f, 0xa0, 0x0, 0x0, 0xaf, 0xb9, + 0xfe, 0x10, 0x0, 0x9, 0xf2, 0x0, 0x0, 0x0, + 0x8e, 0xfb, 0x20, + + /* U+0026 "&" */ + 0x0, 0x0, 0x8e, 0xfd, 0x70, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xfd, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x8f, 0xc1, 0x3, 0xff, 0x30, 0x0, 0x0, 0xc, + 0xf6, 0x0, 0xc, 0xf6, 0x0, 0x0, 0x0, 0xbf, + 0x90, 0x0, 0xdf, 0x50, 0x0, 0x0, 0x5, 0xff, + 0x30, 0x7f, 0xe0, 0x0, 0x0, 0x0, 0xc, 0xfe, + 0xaf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xc2, 0x0, 0x0, 0x0, 0x0, 0x5e, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, 0x8f, 0xf6, + 0x0, 0x62, 0x0, 0x4f, 0xf7, 0x0, 0xaf, 0xf3, + 0x2f, 0xf2, 0xb, 0xfb, 0x0, 0x0, 0xdf, 0xe9, + 0xfd, 0x0, 0xef, 0x50, 0x0, 0x2, 0xef, 0xff, + 0x60, 0xe, 0xf7, 0x0, 0x0, 0x4, 0xff, 0xe0, + 0x0, 0xaf, 0xd0, 0x0, 0x0, 0x6f, 0xff, 0x70, + 0x3, 0xff, 0xa1, 0x1, 0x9f, 0xfd, 0xff, 0x60, + 0x6, 0xff, 0xff, 0xff, 0xf7, 0xc, 0xff, 0x30, + 0x3, 0xae, 0xfe, 0xa3, 0x0, 0xa, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0027 "'" */ + 0xef, 0x8e, 0xf8, 0xef, 0x7d, 0xf6, 0xaf, 0x37, + 0xf0, 0x13, 0x0, + + /* U+0028 "(" */ + 0x0, 0x0, 0xbd, 0x0, 0x0, 0x6f, 0x50, 0x0, + 0x1e, 0xc0, 0x0, 0x8, 0xf5, 0x0, 0x0, 0xff, + 0x0, 0x0, 0x6f, 0x90, 0x0, 0xc, 0xf5, 0x0, + 0x0, 0xff, 0x10, 0x0, 0x4f, 0xe0, 0x0, 0x6, + 0xfc, 0x0, 0x0, 0x8f, 0xb0, 0x0, 0x8, 0xfa, + 0x0, 0x0, 0x8f, 0xb0, 0x0, 0x6, 0xfc, 0x0, + 0x0, 0x4f, 0xe0, 0x0, 0x0, 0xff, 0x10, 0x0, + 0xc, 0xf5, 0x0, 0x0, 0x6f, 0x90, 0x0, 0x1, + 0xff, 0x0, 0x0, 0x8, 0xf5, 0x0, 0x0, 0x1f, + 0xc0, 0x0, 0x0, 0x6f, 0x50, 0x0, 0x0, 0xbd, + 0x0, + + /* U+0029 ")" */ + 0xd, 0xb0, 0x0, 0x0, 0x5f, 0x60, 0x0, 0x0, + 0xce, 0x10, 0x0, 0x5, 0xf8, 0x0, 0x0, 0xf, + 0xf0, 0x0, 0x0, 0x9f, 0x60, 0x0, 0x5, 0xfc, + 0x0, 0x0, 0x1f, 0xf0, 0x0, 0x0, 0xef, 0x40, + 0x0, 0xc, 0xf6, 0x0, 0x0, 0xbf, 0x80, 0x0, + 0xa, 0xf8, 0x0, 0x0, 0xbf, 0x70, 0x0, 0xc, + 0xf6, 0x0, 0x0, 0xef, 0x40, 0x0, 0x1f, 0xf0, + 0x0, 0x5, 0xfc, 0x0, 0x0, 0x9f, 0x60, 0x0, + 0xf, 0xf0, 0x0, 0x5, 0xf8, 0x0, 0x0, 0xce, + 0x10, 0x0, 0x5f, 0x60, 0x0, 0xd, 0xb0, 0x0, + 0x0, + + /* U+002A "*" */ + 0x0, 0x2, 0xf7, 0x0, 0x0, 0x0, 0x1f, 0x60, + 0x0, 0xd, 0xb4, 0xf7, 0x9f, 0x31, 0xbe, 0xff, + 0xff, 0xd4, 0x0, 0xb, 0xfe, 0x20, 0x0, 0x7, + 0xf6, 0xec, 0x0, 0x1, 0xeb, 0x6, 0xf5, 0x0, + 0x1, 0x10, 0x3, 0x0, + + /* U+002B "+" */ + 0x0, 0x0, 0x9, 0x90, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xf0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0xf, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xf0, 0x0, 0x0, + + /* U+002C "," */ + 0x6, 0x73, 0xe, 0xf7, 0xe, 0xf7, 0x0, 0xc6, + 0x1, 0xf3, 0xc, 0xb0, 0x3, 0x0, + + /* U+002D "-" */ + 0x2, 0x22, 0x22, 0x20, 0x3f, 0xff, 0xff, 0xf4, + 0x3f, 0xff, 0xff, 0xf4, + + /* U+002E "." */ + 0x67, 0x3d, 0xf8, 0xdf, 0x80, + + /* U+002F "/" */ + 0x0, 0x0, 0x2f, 0x80, 0x0, 0x6, 0xf4, 0x0, + 0x0, 0xbf, 0x0, 0x0, 0xf, 0xb0, 0x0, 0x4, + 0xf6, 0x0, 0x0, 0x8f, 0x20, 0x0, 0xd, 0xe0, + 0x0, 0x1, 0xf9, 0x0, 0x0, 0x5f, 0x50, 0x0, + 0xa, 0xf0, 0x0, 0x0, 0xec, 0x0, 0x0, 0x3f, + 0x70, 0x0, 0x7, 0xf3, 0x0, 0x0, 0xce, 0x0, + 0x0, 0xf, 0xa0, 0x0, 0x4, 0xf6, 0x0, 0x0, + 0x9f, 0x10, 0x0, 0xd, 0xd0, 0x0, 0x0, + + /* U+0030 "0" */ + 0x0, 0x8, 0xdf, 0xea, 0x20, 0x0, 0x1, 0xdf, + 0xfd, 0xef, 0xf4, 0x0, 0xa, 0xfc, 0x10, 0x8, + 0xfe, 0x0, 0x2f, 0xf1, 0x0, 0x0, 0xcf, 0x60, + 0x7f, 0xb0, 0x0, 0x0, 0x6f, 0xb0, 0xaf, 0x70, + 0x0, 0x0, 0x2f, 0xf0, 0xcf, 0x50, 0x0, 0x0, + 0xf, 0xf1, 0xef, 0x40, 0x0, 0x0, 0xf, 0xf2, + 0xef, 0x30, 0x0, 0x0, 0xf, 0xf3, 0xef, 0x30, + 0x0, 0x0, 0xf, 0xf3, 0xef, 0x40, 0x0, 0x0, + 0xf, 0xf2, 0xcf, 0x50, 0x0, 0x0, 0xf, 0xf1, + 0xaf, 0x70, 0x0, 0x0, 0x2f, 0xf0, 0x7f, 0xb0, + 0x0, 0x0, 0x6f, 0xb0, 0x2f, 0xf1, 0x0, 0x0, + 0xcf, 0x60, 0xa, 0xfc, 0x10, 0x8, 0xfe, 0x0, + 0x1, 0xdf, 0xfc, 0xef, 0xf4, 0x0, 0x0, 0x18, + 0xdf, 0xea, 0x20, 0x0, + + /* U+0031 "1" */ + 0x0, 0x0, 0xa, 0xf0, 0x0, 0x6, 0xff, 0x0, + 0x5, 0xff, 0xf0, 0x19, 0xff, 0xff, 0x3e, 0xff, + 0x7f, 0xf5, 0xfb, 0x22, 0xff, 0x33, 0x0, 0x2f, + 0xf0, 0x0, 0x2, 0xff, 0x0, 0x0, 0x2f, 0xf0, + 0x0, 0x2, 0xff, 0x0, 0x0, 0x2f, 0xf0, 0x0, + 0x2, 0xff, 0x0, 0x0, 0x2f, 0xf0, 0x0, 0x2, + 0xff, 0x0, 0x0, 0x2f, 0xf0, 0x0, 0x2, 0xff, + 0x0, 0x0, 0x2f, 0xf0, 0x0, 0x2, 0xff, + + /* U+0032 "2" */ + 0x0, 0x2, 0x9e, 0xfe, 0xc5, 0x0, 0x0, 0x5, + 0xff, 0xfd, 0xef, 0xfa, 0x0, 0x1, 0xff, 0x90, + 0x0, 0x5f, 0xf6, 0x0, 0x8f, 0xc0, 0x0, 0x0, + 0x7f, 0xd0, 0xb, 0xf7, 0x0, 0x0, 0x2, 0xff, + 0x0, 0x25, 0x20, 0x0, 0x0, 0x2f, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0x60, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xe2, + 0x0, 0x0, 0x0, 0x1, 0xcf, 0xe3, 0x0, 0x0, + 0x0, 0x2, 0xdf, 0xe2, 0x0, 0x0, 0x0, 0x3, + 0xef, 0xd2, 0x0, 0x0, 0x0, 0x2, 0xef, 0xc1, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xc1, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xe2, 0x11, 0x11, 0x11, 0x10, + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0x13, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf1, + + /* U+0033 "3" */ + 0x0, 0x2a, 0xef, 0xe9, 0x20, 0x0, 0x4, 0xff, + 0xec, 0xff, 0xf3, 0x0, 0x1e, 0xf8, 0x0, 0x9, + 0xfe, 0x0, 0x7f, 0xc0, 0x0, 0x0, 0xef, 0x50, + 0x6b, 0x60, 0x0, 0x0, 0xbf, 0x70, 0x0, 0x0, + 0x0, 0x0, 0xef, 0x50, 0x0, 0x0, 0x0, 0x19, + 0xfd, 0x0, 0x0, 0x0, 0x6b, 0xff, 0xc2, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xc5, 0x0, 0x0, 0x0, + 0x10, 0x29, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf2, + 0x3, 0x0, 0x0, 0x0, 0xf, 0xf4, 0xdf, 0x60, + 0x0, 0x0, 0x1f, 0xf3, 0x9f, 0xc0, 0x0, 0x0, + 0x8f, 0xe0, 0x2f, 0xf9, 0x0, 0x6, 0xff, 0x60, + 0x5, 0xff, 0xfd, 0xef, 0xf7, 0x0, 0x0, 0x2a, + 0xef, 0xea, 0x30, 0x0, + + /* U+0034 "4" */ + 0x0, 0x0, 0x0, 0x2, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0xb, 0xf7, 0xfe, 0x0, + 0x0, 0x0, 0x6, 0xf9, 0x3f, 0xe0, 0x0, 0x0, + 0x1, 0xfe, 0x13, 0xfe, 0x0, 0x0, 0x0, 0xbf, + 0x50, 0x3f, 0xe0, 0x0, 0x0, 0x5f, 0xa0, 0x3, + 0xfe, 0x0, 0x0, 0x1e, 0xe1, 0x0, 0x3f, 0xe0, + 0x0, 0xa, 0xf6, 0x0, 0x3, 0xfe, 0x0, 0x5, + 0xfb, 0x0, 0x0, 0x3f, 0xe0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x39, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x3, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xe0, 0x0, + + /* U+0035 "5" */ + 0x0, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x2, 0xff, + 0xff, 0xff, 0xff, 0xa0, 0x5, 0xfb, 0x11, 0x11, + 0x11, 0x0, 0x8, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xf5, 0x0, 0x0, 0x0, 0x0, 0xe, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf3, 0xad, 0xdb, + 0x40, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x6f, 0xf9, 0x20, 0x28, 0xff, 0x80, 0x49, 0x70, + 0x0, 0x0, 0x8f, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0xd, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xf6, 0xdf, 0x60, + 0x0, 0x0, 0x1f, 0xf3, 0xaf, 0xc0, 0x0, 0x0, + 0x8f, 0xd0, 0x3f, 0xf9, 0x0, 0x6, 0xff, 0x40, + 0x6, 0xff, 0xfc, 0xef, 0xf7, 0x0, 0x0, 0x3a, + 0xef, 0xeb, 0x40, 0x0, + + /* U+0036 "6" */ + 0x0, 0x5, 0xbe, 0xfd, 0x70, 0x0, 0x0, 0x9f, + 0xfd, 0xdf, 0xfc, 0x0, 0x7, 0xfd, 0x30, 0x3, + 0xef, 0x70, 0xf, 0xf3, 0x0, 0x0, 0x6f, 0xd0, + 0x5f, 0xb0, 0x0, 0x0, 0x16, 0x50, 0xaf, 0x60, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0x31, 0x9d, 0xdb, + 0x50, 0x0, 0xef, 0x5e, 0xff, 0xff, 0xf9, 0x0, + 0xff, 0xee, 0x40, 0x17, 0xff, 0x60, 0xff, 0xf2, + 0x0, 0x0, 0x8f, 0xe0, 0xff, 0xa0, 0x0, 0x0, + 0x1f, 0xf3, 0xef, 0x70, 0x0, 0x0, 0xe, 0xf4, + 0xbf, 0x80, 0x0, 0x0, 0xe, 0xf4, 0x8f, 0xb0, + 0x0, 0x0, 0xf, 0xf2, 0x3f, 0xf2, 0x0, 0x0, + 0x7f, 0xd0, 0xa, 0xfd, 0x20, 0x4, 0xff, 0x50, + 0x1, 0xcf, 0xfd, 0xdf, 0xf9, 0x0, 0x0, 0x6, + 0xcf, 0xfc, 0x50, 0x0, + + /* U+0037 "7" */ + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xf5, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x11, 0x11, 0x11, 0x11, + 0xcf, 0xa0, 0x0, 0x0, 0x0, 0x7, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xa0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0x20, 0x0, 0x0, 0x0, 0xb, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xef, 0x50, + 0x0, 0x0, 0x0, 0x4, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0xf, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xc0, 0x0, 0x0, 0x0, + + /* U+0038 "8" */ + 0x0, 0x19, 0xef, 0xeb, 0x30, 0x0, 0x2, 0xef, + 0xfd, 0xef, 0xf6, 0x0, 0xc, 0xfc, 0x10, 0x8, + 0xff, 0x20, 0x2f, 0xf1, 0x0, 0x0, 0xcf, 0x70, + 0x4f, 0xe0, 0x0, 0x0, 0x9f, 0x90, 0x2f, 0xf1, + 0x0, 0x0, 0xbf, 0x70, 0xc, 0xfb, 0x10, 0x7, + 0xff, 0x10, 0x1, 0xbf, 0xfd, 0xef, 0xd3, 0x0, + 0x1, 0x8f, 0xff, 0xff, 0xc3, 0x0, 0x1d, 0xfb, + 0x30, 0x18, 0xff, 0x40, 0x8f, 0xd0, 0x0, 0x0, + 0x7f, 0xd0, 0xdf, 0x60, 0x0, 0x0, 0xf, 0xf3, + 0xff, 0x30, 0x0, 0x0, 0xd, 0xf4, 0xef, 0x50, + 0x0, 0x0, 0xf, 0xf4, 0xaf, 0xb0, 0x0, 0x0, + 0x5f, 0xf0, 0x3f, 0xf8, 0x0, 0x4, 0xef, 0x80, + 0x5, 0xff, 0xfc, 0xef, 0xfa, 0x0, 0x0, 0x29, + 0xef, 0xeb, 0x50, 0x0, + + /* U+0039 "9" */ + 0x0, 0x2a, 0xef, 0xd9, 0x10, 0x0, 0x4, 0xff, + 0xfd, 0xef, 0xe3, 0x0, 0x1e, 0xfb, 0x10, 0x6, + 0xfe, 0x10, 0x7f, 0xe0, 0x0, 0x0, 0xaf, 0x80, + 0xcf, 0x80, 0x0, 0x0, 0x3f, 0xe0, 0xef, 0x40, + 0x0, 0x0, 0x1f, 0xf1, 0xef, 0x40, 0x0, 0x0, + 0x1f, 0xf3, 0xcf, 0x70, 0x0, 0x0, 0x4f, 0xf4, + 0x8f, 0xe0, 0x0, 0x0, 0xbf, 0xf5, 0x1e, 0xfc, + 0x30, 0x19, 0xfe, 0xf4, 0x4, 0xff, 0xff, 0xff, + 0x7c, 0xf4, 0x0, 0x29, 0xdd, 0xa3, 0xd, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xf0, 0x25, 0x30, + 0x0, 0x0, 0x5f, 0xb0, 0x7f, 0xa0, 0x0, 0x0, + 0xdf, 0x50, 0x2f, 0xf5, 0x0, 0xa, 0xfc, 0x0, + 0x7, 0xff, 0xec, 0xff, 0xd1, 0x0, 0x0, 0x4b, + 0xff, 0xd8, 0x0, 0x0, + + /* U+003A ":" */ + 0xdf, 0x8d, 0xf8, 0x67, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x67, + 0x3d, 0xf8, 0xdf, 0x80, + + /* U+003B ";" */ + 0xe, 0xf7, 0xe, 0xf7, 0x6, 0x73, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0x73, 0xe, 0xf7, + 0xe, 0xf7, 0x0, 0xc6, 0x1, 0xf3, 0xc, 0xb0, + 0x3, 0x0, + + /* U+003C "<" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x14, 0x0, 0x0, + 0x0, 0x0, 0x3a, 0xfb, 0x0, 0x0, 0x0, 0x5c, + 0xff, 0xf7, 0x0, 0x1, 0x7e, 0xff, 0xe7, 0x10, + 0x2, 0x9f, 0xff, 0xb5, 0x0, 0x0, 0x8f, 0xff, + 0x92, 0x0, 0x0, 0x0, 0xaf, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x5d, 0xff, 0xe7, 0x10, 0x0, 0x0, + 0x0, 0x4b, 0xff, 0xf9, 0x30, 0x0, 0x0, 0x0, + 0x29, 0xff, 0xfc, 0x50, 0x0, 0x0, 0x0, 0x17, + 0xef, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x5, 0xcb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + + /* U+003D "=" */ + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+003E ">" */ + 0x41, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xa3, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xc5, 0x0, + 0x0, 0x0, 0x1, 0x7e, 0xff, 0xe7, 0x10, 0x0, + 0x0, 0x0, 0x5b, 0xff, 0xf9, 0x30, 0x0, 0x0, + 0x0, 0x29, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xfb, 0x0, 0x0, 0x1, 0x7d, 0xff, 0xd5, + 0x0, 0x2, 0x9f, 0xff, 0xb4, 0x0, 0x5, 0xcf, + 0xff, 0x92, 0x0, 0x0, 0xaf, 0xfe, 0x71, 0x0, + 0x0, 0x0, 0xac, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+003F "?" */ + 0x0, 0x29, 0xef, 0xeb, 0x50, 0x0, 0x5, 0xff, + 0xfd, 0xef, 0xfa, 0x0, 0x1f, 0xfa, 0x0, 0x5, + 0xff, 0x80, 0x8f, 0xd0, 0x0, 0x0, 0x6f, 0xf0, + 0xcf, 0x70, 0x0, 0x0, 0x1f, 0xf2, 0x24, 0x10, + 0x0, 0x0, 0x1f, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xd0, 0x0, 0x0, 0x0, 0x5, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x5f, 0xf7, 0x0, 0x0, 0x0, + 0x4, 0xff, 0x70, 0x0, 0x0, 0x0, 0xe, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x4a, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x37, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xd0, 0x0, 0x0, + + /* U+0040 "@" */ + 0x0, 0x0, 0x0, 0x3, 0x8c, 0xdf, 0xfd, 0xb7, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3c, 0xff, + 0xfd, 0xcc, 0xef, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xfb, 0x50, 0x0, 0x0, 0x27, 0xef, + 0xc1, 0x0, 0x0, 0x0, 0x6f, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xc0, 0x0, 0x0, 0x3f, + 0xe3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0x90, 0x0, 0xd, 0xf4, 0x0, 0x4, 0xbf, 0xea, + 0x13, 0xfd, 0x0, 0xdf, 0x20, 0x5, 0xf8, 0x0, + 0x7, 0xff, 0xde, 0xfd, 0x7f, 0xa0, 0x5, 0xf8, + 0x0, 0xcf, 0x10, 0x5, 0xff, 0x40, 0x4, 0xff, + 0xf6, 0x0, 0xf, 0xc0, 0x1f, 0xa0, 0x1, 0xef, + 0x50, 0x0, 0x9, 0xff, 0x30, 0x0, 0xde, 0x5, + 0xf6, 0x0, 0x8f, 0xc0, 0x0, 0x0, 0x5f, 0xf0, + 0x0, 0xc, 0xf0, 0x8f, 0x30, 0xd, 0xf5, 0x0, + 0x0, 0x3, 0xfd, 0x0, 0x0, 0xee, 0x9, 0xf2, + 0x1, 0xff, 0x10, 0x0, 0x0, 0x5f, 0x90, 0x0, + 0x1f, 0xb0, 0x9f, 0x10, 0x2f, 0xf0, 0x0, 0x0, + 0xa, 0xf6, 0x0, 0x7, 0xf6, 0x8, 0xf3, 0x1, + 0xff, 0x10, 0x0, 0x2, 0xff, 0x30, 0x1, 0xee, + 0x0, 0x6f, 0x50, 0xe, 0xf6, 0x0, 0x0, 0xcf, + 0xf0, 0x0, 0xbf, 0x60, 0x2, 0xfa, 0x0, 0x8f, + 0xf4, 0x3, 0xcf, 0xff, 0x13, 0xcf, 0x90, 0x0, + 0xe, 0xf1, 0x0, 0xdf, 0xff, 0xff, 0x7f, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x6f, 0xa0, 0x1, 0x9e, + 0xfa, 0x20, 0x9f, 0xeb, 0x40, 0x2, 0x42, 0x0, + 0xdf, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0x20, 0x1, 0xef, 0x91, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0x40, 0x0, 0x2, + 0xdf, 0xe9, 0x40, 0x0, 0x0, 0x2, 0x7d, 0xfe, + 0x30, 0x0, 0x0, 0x0, 0x8e, 0xff, 0xfe, 0xdc, + 0xdf, 0xff, 0xf9, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x5, 0x9c, 0xef, 0xfe, 0xda, 0x61, 0x0, 0x0, + 0x0, + + /* U+0041 "A" */ + 0x0, 0x0, 0x0, 0x9, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xbf, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0x6c, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0x27, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xfd, 0x2, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xf7, 0x0, 0xcf, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xf2, 0x0, 0x7f, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xc0, 0x0, 0x1f, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0xef, 0x70, 0x0, 0xc, 0xfb, + 0x0, 0x0, 0x0, 0x4, 0xff, 0x20, 0x0, 0x6, + 0xff, 0x20, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0xf, 0xfe, 0xee, + 0xee, 0xee, 0xff, 0xe0, 0x0, 0x0, 0x5f, 0xf1, + 0x0, 0x0, 0x0, 0x4f, 0xf4, 0x0, 0x0, 0xbf, + 0xb0, 0x0, 0x0, 0x0, 0xe, 0xfb, 0x0, 0x1, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x8, 0xff, 0x10, + 0x7, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0x70, 0xd, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xd0, + + /* U+0042 "B" */ + 0x3f, 0xff, 0xff, 0xff, 0xeb, 0x40, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x3f, 0xf1, + 0x11, 0x11, 0x39, 0xff, 0x50, 0x3f, 0xf0, 0x0, + 0x0, 0x0, 0xbf, 0xb0, 0x3f, 0xf0, 0x0, 0x0, + 0x0, 0x6f, 0xd0, 0x3f, 0xf0, 0x0, 0x0, 0x0, + 0x5f, 0xd0, 0x3f, 0xf0, 0x0, 0x0, 0x0, 0xaf, + 0x90, 0x3f, 0xf1, 0x11, 0x11, 0x39, 0xfe, 0x10, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xd2, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x20, 0x3f, 0xf0, + 0x0, 0x0, 0x15, 0xdf, 0xe0, 0x3f, 0xf0, 0x0, + 0x0, 0x0, 0x1e, 0xf7, 0x3f, 0xf0, 0x0, 0x0, + 0x0, 0xa, 0xfa, 0x3f, 0xf0, 0x0, 0x0, 0x0, + 0xb, 0xfb, 0x3f, 0xf0, 0x0, 0x0, 0x0, 0x1e, + 0xf8, 0x3f, 0xf1, 0x11, 0x11, 0x25, 0xdf, 0xf2, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x3f, + 0xff, 0xff, 0xff, 0xfc, 0x92, 0x0, + + /* U+0043 "C" */ + 0x0, 0x0, 0x18, 0xce, 0xfe, 0xb5, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xb1, 0x0, + 0x0, 0x9f, 0xfa, 0x41, 0x2, 0x8f, 0xfc, 0x0, + 0x5, 0xff, 0x60, 0x0, 0x0, 0x4, 0xff, 0x70, + 0xe, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xe0, + 0x4f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x27, 0x30, + 0x8f, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x10, + 0x3f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf4, + 0xd, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf0, + 0x5, 0xff, 0x60, 0x0, 0x0, 0x4, 0xff, 0x80, + 0x0, 0xaf, 0xfa, 0x30, 0x2, 0x8f, 0xfc, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xb1, 0x0, + 0x0, 0x0, 0x39, 0xde, 0xfe, 0xb5, 0x0, 0x0, + + /* U+0044 "D" */ + 0x1f, 0xff, 0xff, 0xff, 0xec, 0x81, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x1f, 0xf3, 0x11, 0x11, 0x36, 0xdf, 0xf3, 0x0, + 0x1f, 0xf2, 0x0, 0x0, 0x0, 0xc, 0xfd, 0x0, + 0x1f, 0xf2, 0x0, 0x0, 0x0, 0x2, 0xff, 0x50, + 0x1f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xa0, + 0x1f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xe0, + 0x1f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf0, + 0x1f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf1, + 0x1f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf1, + 0x1f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf0, + 0x1f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xd0, + 0x1f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xa0, + 0x1f, 0xf2, 0x0, 0x0, 0x0, 0x3, 0xff, 0x40, + 0x1f, 0xf2, 0x0, 0x0, 0x0, 0xd, 0xfd, 0x0, + 0x1f, 0xf3, 0x11, 0x11, 0x37, 0xdf, 0xf3, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x40, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xeb, 0x61, 0x0, 0x0, + + /* U+0045 "E" */ + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x1f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x1f, 0xf3, + 0x11, 0x11, 0x11, 0x11, 0x10, 0x1f, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x1f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x1f, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xf3, 0x11, 0x11, 0x11, 0x11, 0x10, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x1f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, + + /* U+0046 "F" */ + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x81, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf8, 0x1f, 0xf4, 0x11, + 0x11, 0x11, 0x11, 0x1, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xf4, 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x40, 0x1f, 0xf4, 0x11, 0x11, 0x11, 0x10, 0x1, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, + + /* U+0047 "G" */ + 0x0, 0x0, 0x17, 0xbe, 0xff, 0xda, 0x30, 0x0, + 0x0, 0x0, 0x5e, 0xff, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x6f, 0xfc, 0x52, 0x1, 0x3a, 0xff, + 0x90, 0x0, 0x3f, 0xf9, 0x0, 0x0, 0x0, 0x6, + 0xff, 0x30, 0xc, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xfa, 0x2, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x49, 0x40, 0x7f, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0x90, 0x0, 0x0, + 0x1, 0x11, 0x11, 0x11, 0xb, 0xfa, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0xf2, 0xaf, 0xb0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xff, 0x27, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf2, 0x3f, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0x20, 0xcf, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf2, 0x3, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x9, 0xff, 0x20, + 0x6, 0xff, 0xe8, 0x32, 0x24, 0x9f, 0xff, 0xb0, + 0x0, 0x4, 0xef, 0xff, 0xff, 0xff, 0xfe, 0x60, + 0x0, 0x0, 0x0, 0x6a, 0xef, 0xfd, 0xa6, 0x0, + 0x0, + + /* U+0048 "H" */ + 0x1f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xef, 0x61, + 0xff, 0x30, 0x0, 0x0, 0x0, 0xe, 0xf6, 0x1f, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0xef, 0x61, 0xff, + 0x30, 0x0, 0x0, 0x0, 0xe, 0xf6, 0x1f, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0xef, 0x61, 0xff, 0x30, + 0x0, 0x0, 0x0, 0xe, 0xf6, 0x1f, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0xef, 0x61, 0xff, 0x41, 0x11, + 0x11, 0x11, 0x1e, 0xf6, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x61, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf6, 0x1f, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0xef, 0x61, 0xff, 0x30, 0x0, 0x0, 0x0, + 0xe, 0xf6, 0x1f, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0xef, 0x61, 0xff, 0x30, 0x0, 0x0, 0x0, 0xe, + 0xf6, 0x1f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xef, + 0x61, 0xff, 0x30, 0x0, 0x0, 0x0, 0xe, 0xf6, + 0x1f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xef, 0x61, + 0xff, 0x30, 0x0, 0x0, 0x0, 0xe, 0xf6, + + /* U+0049 "I" */ + 0xcf, 0x7c, 0xf7, 0xcf, 0x7c, 0xf7, 0xcf, 0x7c, + 0xf7, 0xcf, 0x7c, 0xf7, 0xcf, 0x7c, 0xf7, 0xcf, + 0x7c, 0xf7, 0xcf, 0x7c, 0xf7, 0xcf, 0x7c, 0xf7, + 0xcf, 0x7c, 0xf7, + + /* U+004A "J" */ + 0x0, 0x0, 0x0, 0x2, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x2f, 0xf2, 0x0, 0x0, 0x0, 0x2, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x2f, 0xf2, 0x0, 0x0, + 0x0, 0x2, 0xff, 0x20, 0x0, 0x0, 0x0, 0x2f, + 0xf2, 0x0, 0x0, 0x0, 0x2, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x2f, 0xf2, 0x0, 0x0, 0x0, 0x2, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x2f, 0xf2, 0x0, + 0x0, 0x0, 0x2, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x2f, 0xf2, 0x16, 0x60, 0x0, 0x2, 0xff, 0x14, + 0xfe, 0x0, 0x0, 0x3f, 0xf0, 0x2f, 0xf2, 0x0, + 0x7, 0xfe, 0x0, 0xdf, 0xd3, 0x15, 0xff, 0x90, + 0x4, 0xff, 0xff, 0xff, 0xd1, 0x0, 0x3, 0xbe, + 0xfd, 0x81, 0x0, + + /* U+004B "K" */ + 0x3f, 0xf0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0x33, + 0xff, 0x0, 0x0, 0x0, 0xc, 0xff, 0x30, 0x3f, + 0xf0, 0x0, 0x0, 0xc, 0xff, 0x30, 0x3, 0xff, + 0x0, 0x0, 0xb, 0xff, 0x30, 0x0, 0x3f, 0xf0, + 0x0, 0xb, 0xff, 0x40, 0x0, 0x3, 0xff, 0x0, + 0xa, 0xff, 0x40, 0x0, 0x0, 0x3f, 0xf0, 0xa, + 0xff, 0x40, 0x0, 0x0, 0x3, 0xff, 0x9, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x3f, 0xf9, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x3, 0xff, 0xff, 0x4b, 0xfe, + 0x10, 0x0, 0x0, 0x3f, 0xff, 0x40, 0x1f, 0xfb, + 0x0, 0x0, 0x3, 0xff, 0x50, 0x0, 0x6f, 0xf6, + 0x0, 0x0, 0x3f, 0xf0, 0x0, 0x0, 0xbf, 0xf2, + 0x0, 0x3, 0xff, 0x0, 0x0, 0x1, 0xff, 0xc0, + 0x0, 0x3f, 0xf0, 0x0, 0x0, 0x6, 0xff, 0x80, + 0x3, 0xff, 0x0, 0x0, 0x0, 0xb, 0xff, 0x30, + 0x3f, 0xf0, 0x0, 0x0, 0x0, 0x1e, 0xfd, 0x3, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf9, + + /* U+004C "L" */ + 0x3f, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xf2, 0x11, 0x11, 0x11, 0x10, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xf8, + + /* U+004D "M" */ + 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf3, 0x3f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf3, 0x3f, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf3, 0x3f, 0xfb, 0xf5, 0x0, 0x0, + 0x0, 0xf, 0xdf, 0xf3, 0x3f, 0xf6, 0xfa, 0x0, + 0x0, 0x0, 0x5f, 0x7f, 0xf3, 0x3f, 0xf1, 0xff, + 0x0, 0x0, 0x0, 0xaf, 0x2f, 0xf3, 0x3f, 0xf0, + 0xcf, 0x40, 0x0, 0x0, 0xfd, 0xf, 0xf3, 0x3f, + 0xf0, 0x6f, 0x90, 0x0, 0x5, 0xf7, 0xf, 0xf3, + 0x3f, 0xf0, 0x1f, 0xe0, 0x0, 0xa, 0xf2, 0xf, + 0xf3, 0x3f, 0xf0, 0xc, 0xf4, 0x0, 0xf, 0xd0, + 0xf, 0xf3, 0x3f, 0xf0, 0x7, 0xf9, 0x0, 0x4f, + 0x80, 0xf, 0xf3, 0x3f, 0xf0, 0x2, 0xfe, 0x0, + 0xaf, 0x20, 0xf, 0xf3, 0x3f, 0xf0, 0x0, 0xdf, + 0x30, 0xed, 0x0, 0xf, 0xf3, 0x3f, 0xf0, 0x0, + 0x7f, 0x84, 0xf8, 0x0, 0xf, 0xf3, 0x3f, 0xf0, + 0x0, 0x2f, 0xd9, 0xf2, 0x0, 0xf, 0xf3, 0x3f, + 0xf0, 0x0, 0xd, 0xff, 0xd0, 0x0, 0xf, 0xf3, + 0x3f, 0xf0, 0x0, 0x8, 0xff, 0x80, 0x0, 0xf, + 0xf3, 0x3f, 0xf0, 0x0, 0x3, 0xff, 0x20, 0x0, + 0xf, 0xf3, + + /* U+004E "N" */ + 0x1f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xcf, 0x71, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0xc, 0xf7, 0x1f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0xcf, 0x71, 0xff, + 0xff, 0x70, 0x0, 0x0, 0xc, 0xf7, 0x1f, 0xf9, + 0xff, 0x20, 0x0, 0x0, 0xcf, 0x71, 0xff, 0x1d, + 0xfb, 0x0, 0x0, 0xc, 0xf7, 0x1f, 0xf1, 0x3f, + 0xf6, 0x0, 0x0, 0xcf, 0x71, 0xff, 0x10, 0x9f, + 0xe1, 0x0, 0xc, 0xf7, 0x1f, 0xf1, 0x0, 0xef, + 0xa0, 0x0, 0xcf, 0x71, 0xff, 0x10, 0x5, 0xff, + 0x40, 0xc, 0xf7, 0x1f, 0xf1, 0x0, 0xa, 0xfe, + 0x0, 0xcf, 0x71, 0xff, 0x10, 0x0, 0x1f, 0xf9, + 0xc, 0xf7, 0x1f, 0xf1, 0x0, 0x0, 0x6f, 0xf3, + 0xcf, 0x71, 0xff, 0x10, 0x0, 0x0, 0xcf, 0xdc, + 0xf7, 0x1f, 0xf1, 0x0, 0x0, 0x2, 0xff, 0xff, + 0x71, 0xff, 0x10, 0x0, 0x0, 0x7, 0xff, 0xf7, + 0x1f, 0xf1, 0x0, 0x0, 0x0, 0xd, 0xff, 0x71, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x3f, 0xf7, + + /* U+004F "O" */ + 0x0, 0x0, 0x18, 0xce, 0xfe, 0xb6, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xfd, 0x30, + 0x0, 0x0, 0x8f, 0xfb, 0x41, 0x2, 0x6e, 0xff, + 0x40, 0x0, 0x5f, 0xf7, 0x0, 0x0, 0x0, 0xc, + 0xfe, 0x10, 0xe, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xf9, 0x5, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xf0, 0x9f, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0x4c, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xf7, 0xdf, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0x8d, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xf8, 0xbf, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0x79, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf4, 0x4f, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x0, 0xef, + 0xa0, 0x0, 0x0, 0x0, 0x1, 0xef, 0x90, 0x5, + 0xff, 0x70, 0x0, 0x0, 0x0, 0xbf, 0xe1, 0x0, + 0x9, 0xff, 0xb4, 0x0, 0x16, 0xef, 0xf4, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xd3, 0x0, + 0x0, 0x0, 0x1, 0x8c, 0xff, 0xeb, 0x60, 0x0, + 0x0, + + /* U+0050 "P" */ + 0x2f, 0xff, 0xff, 0xff, 0xed, 0xa3, 0x0, 0x2f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x2f, 0xf2, + 0x11, 0x11, 0x13, 0xbf, 0xf3, 0x2f, 0xf2, 0x0, + 0x0, 0x0, 0xd, 0xfa, 0x2f, 0xf2, 0x0, 0x0, + 0x0, 0x8, 0xfd, 0x2f, 0xf2, 0x0, 0x0, 0x0, + 0x6, 0xff, 0x2f, 0xf2, 0x0, 0x0, 0x0, 0x8, + 0xfd, 0x2f, 0xf2, 0x0, 0x0, 0x0, 0x1e, 0xf9, + 0x2f, 0xf3, 0x11, 0x11, 0x25, 0xdf, 0xf2, 0x2f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x2f, 0xff, + 0xff, 0xff, 0xfd, 0x92, 0x0, 0x2f, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0051 "Q" */ + 0x0, 0x0, 0x18, 0xce, 0xfe, 0xb6, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xfd, 0x20, + 0x0, 0x0, 0x8f, 0xfb, 0x41, 0x1, 0x6d, 0xff, + 0x40, 0x0, 0x5f, 0xf7, 0x0, 0x0, 0x0, 0xb, + 0xfe, 0x10, 0xe, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xf9, 0x5, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xe0, 0x9f, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0x4c, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xf6, 0xdf, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0x8d, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xf8, 0xcf, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0x79, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf4, 0x4f, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0x0, 0xdf, + 0xa0, 0x0, 0x3, 0xe8, 0x1, 0xef, 0x90, 0x4, + 0xff, 0x70, 0x0, 0x5e, 0xfe, 0xcf, 0xe1, 0x0, + 0x8, 0xff, 0xb4, 0x0, 0x2d, 0xff, 0xf4, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc3, + 0x0, 0x0, 0x2, 0x8c, 0xef, 0xeb, 0x61, 0x9f, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3b, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0052 "R" */ + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xda, 0x30, 0x0, + 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x1f, 0xf3, 0x0, 0x0, 0x0, 0x3c, 0xff, + 0x10, 0x1, 0xff, 0x30, 0x0, 0x0, 0x0, 0x2f, + 0xf7, 0x0, 0x1f, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0x90, 0x1, 0xff, 0x30, 0x0, 0x0, 0x0, + 0xc, 0xf9, 0x0, 0x1f, 0xf3, 0x0, 0x0, 0x0, + 0x2, 0xff, 0x60, 0x1, 0xff, 0x30, 0x0, 0x0, + 0x16, 0xef, 0xe0, 0x0, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe2, 0x0, 0x1, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x60, 0x0, 0x0, 0x1f, 0xf3, 0x0, + 0x15, 0xdf, 0xc1, 0x0, 0x0, 0x1, 0xff, 0x30, + 0x0, 0x1, 0xdf, 0xd0, 0x0, 0x0, 0x1f, 0xf3, + 0x0, 0x0, 0x3, 0xff, 0xa0, 0x0, 0x1, 0xff, + 0x30, 0x0, 0x0, 0x8, 0xff, 0x40, 0x0, 0x1f, + 0xf3, 0x0, 0x0, 0x0, 0xe, 0xfe, 0x0, 0x1, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x4f, 0xf8, 0x0, + 0x1f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf2, + 0x1, 0xff, 0x30, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xc0, + + /* U+0053 "S" */ + 0x0, 0x5, 0xbe, 0xff, 0xd9, 0x30, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x9, 0xff, + 0x83, 0x11, 0x4b, 0xff, 0x60, 0x1f, 0xf4, 0x0, + 0x0, 0x0, 0xaf, 0xe0, 0x3f, 0xf0, 0x0, 0x0, + 0x0, 0x2f, 0xf2, 0x2f, 0xf2, 0x0, 0x0, 0x0, + 0x5, 0x40, 0xd, 0xfd, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xb7, 0x30, 0x0, 0x0, + 0x0, 0x2b, 0xff, 0xff, 0xfe, 0x91, 0x0, 0x0, + 0x0, 0x16, 0xae, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x38, 0xef, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xf8, 0xdf, 0x50, 0x0, 0x0, + 0x0, 0x8, 0xfb, 0xbf, 0xa0, 0x0, 0x0, 0x0, + 0x8, 0xfa, 0x6f, 0xf5, 0x0, 0x0, 0x0, 0x1e, + 0xf6, 0xc, 0xff, 0xb5, 0x21, 0x37, 0xef, 0xe0, + 0x1, 0xbf, 0xff, 0xff, 0xff, 0xfd, 0x20, 0x0, + 0x4, 0xad, 0xff, 0xeb, 0x60, 0x0, + + /* U+0054 "T" */ + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x27, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x1, + 0x11, 0x11, 0xdf, 0x71, 0x11, 0x11, 0x0, 0x0, + 0x0, 0xd, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xf7, 0x0, 0x0, 0x0, + + /* U+0055 "U" */ + 0x1f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xdf, 0x61, + 0xff, 0x30, 0x0, 0x0, 0x0, 0xd, 0xf6, 0x1f, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0xdf, 0x61, 0xff, + 0x30, 0x0, 0x0, 0x0, 0xd, 0xf6, 0x1f, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0x61, 0xff, 0x30, + 0x0, 0x0, 0x0, 0xd, 0xf6, 0x1f, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0x61, 0xff, 0x30, 0x0, + 0x0, 0x0, 0xd, 0xf6, 0x1f, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0x61, 0xff, 0x30, 0x0, 0x0, + 0x0, 0xd, 0xf6, 0x1f, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0x60, 0xff, 0x30, 0x0, 0x0, 0x0, + 0xe, 0xf5, 0xe, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0xff, 0x40, 0xbf, 0x90, 0x0, 0x0, 0x0, 0x4f, + 0xf1, 0x7, 0xff, 0x20, 0x0, 0x0, 0xc, 0xfc, + 0x0, 0xe, 0xff, 0x73, 0x12, 0x5c, 0xff, 0x40, + 0x0, 0x3e, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x17, 0xce, 0xfe, 0xc8, 0x20, 0x0, + + /* U+0056 "V" */ + 0xbf, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xfa, + 0x5f, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xf, 0xf4, + 0xe, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xe0, + 0x9, 0xfc, 0x0, 0x0, 0x0, 0x0, 0xbf, 0x80, + 0x3, 0xff, 0x10, 0x0, 0x0, 0x1, 0xff, 0x20, + 0x0, 0xdf, 0x70, 0x0, 0x0, 0x7, 0xfc, 0x0, + 0x0, 0x7f, 0xc0, 0x0, 0x0, 0xc, 0xf6, 0x0, + 0x0, 0x1f, 0xf2, 0x0, 0x0, 0x2f, 0xf0, 0x0, + 0x0, 0xb, 0xf7, 0x0, 0x0, 0x8f, 0xa0, 0x0, + 0x0, 0x5, 0xfd, 0x0, 0x0, 0xdf, 0x40, 0x0, + 0x0, 0x0, 0xff, 0x20, 0x3, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0x80, 0x9, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xd0, 0xe, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xf2, 0x4f, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xf8, 0x9f, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xfc, 0xef, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xf4, 0x0, 0x0, 0x0, + + /* U+0057 "W" */ + 0xaf, 0xa0, 0x0, 0x0, 0x2, 0xff, 0xd0, 0x0, + 0x0, 0x1, 0xff, 0x35, 0xfe, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x10, 0x0, 0x0, 0x4f, 0xe0, 0x1f, + 0xf2, 0x0, 0x0, 0xb, 0xfd, 0xf6, 0x0, 0x0, + 0x8, 0xfa, 0x0, 0xdf, 0x50, 0x0, 0x0, 0xff, + 0x6f, 0xa0, 0x0, 0x0, 0xcf, 0x60, 0x9, 0xf9, + 0x0, 0x0, 0x3f, 0xb2, 0xfe, 0x0, 0x0, 0xf, + 0xf2, 0x0, 0x5f, 0xc0, 0x0, 0x8, 0xf7, 0xd, + 0xf3, 0x0, 0x3, 0xfe, 0x0, 0x1, 0xff, 0x0, + 0x0, 0xcf, 0x20, 0x9f, 0x70, 0x0, 0x7f, 0xa0, + 0x0, 0xd, 0xf3, 0x0, 0x1f, 0xe0, 0x5, 0xfb, + 0x0, 0xb, 0xf6, 0x0, 0x0, 0x9f, 0x70, 0x5, + 0xfa, 0x0, 0x1f, 0xf0, 0x0, 0xef, 0x10, 0x0, + 0x5, 0xfa, 0x0, 0x9f, 0x60, 0x0, 0xcf, 0x40, + 0x2f, 0xd0, 0x0, 0x0, 0x1f, 0xe0, 0xd, 0xf1, + 0x0, 0x8, 0xf8, 0x6, 0xf9, 0x0, 0x0, 0x0, + 0xdf, 0x12, 0xfd, 0x0, 0x0, 0x4f, 0xb0, 0xaf, + 0x50, 0x0, 0x0, 0x9, 0xf5, 0x6f, 0x90, 0x0, + 0x0, 0xff, 0xd, 0xf1, 0x0, 0x0, 0x0, 0x5f, + 0x89, 0xf5, 0x0, 0x0, 0xc, 0xf3, 0xfc, 0x0, + 0x0, 0x0, 0x1, 0xfb, 0xdf, 0x10, 0x0, 0x0, + 0x7f, 0xaf, 0x80, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xc0, 0x0, 0x0, 0x3, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf8, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0x40, + 0x0, 0x0, 0x0, 0xbf, 0xc0, 0x0, 0x0, + + /* U+0058 "X" */ + 0xc, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xe1, + 0x2, 0xff, 0x90, 0x0, 0x0, 0x3, 0xff, 0x50, + 0x0, 0x6f, 0xf4, 0x0, 0x0, 0xd, 0xf9, 0x0, + 0x0, 0xb, 0xfe, 0x10, 0x0, 0xaf, 0xd0, 0x0, + 0x0, 0x1, 0xff, 0xa0, 0x5, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x6f, 0xf4, 0x1e, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xfd, 0xbf, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xfd, 0xef, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xf4, 0x5f, 0xf6, 0x0, 0x0, + 0x0, 0x1, 0xef, 0x90, 0xa, 0xff, 0x20, 0x0, + 0x0, 0xb, 0xfe, 0x0, 0x1, 0xef, 0xc0, 0x0, + 0x0, 0x6f, 0xf4, 0x0, 0x0, 0x5f, 0xf7, 0x0, + 0x2, 0xff, 0x80, 0x0, 0x0, 0xa, 0xff, 0x20, + 0xc, 0xfd, 0x0, 0x0, 0x0, 0x1, 0xef, 0xc0, + 0x8f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf8, + + /* U+0059 "Y" */ + 0x9f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xf7, + 0x1e, 0xfc, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xd0, + 0x5, 0xff, 0x60, 0x0, 0x0, 0x6, 0xff, 0x30, + 0x0, 0xbf, 0xe1, 0x0, 0x0, 0x1e, 0xf8, 0x0, + 0x0, 0x1f, 0xfa, 0x0, 0x0, 0xaf, 0xd0, 0x0, + 0x0, 0x6, 0xff, 0x40, 0x4, 0xff, 0x30, 0x0, + 0x0, 0x0, 0xcf, 0xd0, 0xd, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xf6, 0x7f, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xfe, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf0, 0x0, 0x0, 0x0, + + /* U+005A "Z" */ + 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x11, 0x11, 0x11, 0x11, 0x6f, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0x71, 0x11, 0x11, 0x11, 0x11, 0x10, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, + + /* U+005B "[" */ + 0x6f, 0xff, 0xf4, 0x6f, 0xec, 0xc3, 0x6f, 0xb0, + 0x0, 0x6f, 0xb0, 0x0, 0x6f, 0xb0, 0x0, 0x6f, + 0xb0, 0x0, 0x6f, 0xb0, 0x0, 0x6f, 0xb0, 0x0, + 0x6f, 0xb0, 0x0, 0x6f, 0xb0, 0x0, 0x6f, 0xb0, + 0x0, 0x6f, 0xb0, 0x0, 0x6f, 0xb0, 0x0, 0x6f, + 0xb0, 0x0, 0x6f, 0xb0, 0x0, 0x6f, 0xb0, 0x0, + 0x6f, 0xb0, 0x0, 0x6f, 0xb0, 0x0, 0x6f, 0xb0, + 0x0, 0x6f, 0xb0, 0x0, 0x6f, 0xb0, 0x0, 0x6f, + 0xec, 0xc3, 0x6f, 0xff, 0xf4, + + /* U+005C "\\" */ + 0xdd, 0x0, 0x0, 0x9, 0xf1, 0x0, 0x0, 0x4f, + 0x60, 0x0, 0x0, 0xfa, 0x0, 0x0, 0xc, 0xe0, + 0x0, 0x0, 0x7f, 0x30, 0x0, 0x3, 0xf7, 0x0, + 0x0, 0xe, 0xc0, 0x0, 0x0, 0xaf, 0x0, 0x0, + 0x5, 0xf5, 0x0, 0x0, 0x1f, 0x90, 0x0, 0x0, + 0xde, 0x0, 0x0, 0x8, 0xf2, 0x0, 0x0, 0x4f, + 0x60, 0x0, 0x0, 0xfb, 0x0, 0x0, 0xb, 0xf0, + 0x0, 0x0, 0x6f, 0x40, 0x0, 0x2, 0xf8, + + /* U+005D "]" */ + 0x9f, 0xff, 0xf1, 0x7c, 0xcf, 0xf1, 0x0, 0xf, + 0xf1, 0x0, 0xf, 0xf1, 0x0, 0xf, 0xf1, 0x0, + 0xf, 0xf1, 0x0, 0xf, 0xf1, 0x0, 0xf, 0xf1, + 0x0, 0xf, 0xf1, 0x0, 0xf, 0xf1, 0x0, 0xf, + 0xf1, 0x0, 0xf, 0xf1, 0x0, 0xf, 0xf1, 0x0, + 0xf, 0xf1, 0x0, 0xf, 0xf1, 0x0, 0xf, 0xf1, + 0x0, 0xf, 0xf1, 0x0, 0xf, 0xf1, 0x0, 0xf, + 0xf1, 0x0, 0xf, 0xf1, 0x0, 0xf, 0xf1, 0x7c, + 0xcf, 0xf1, 0x9f, 0xff, 0xf1, + + /* U+005E "^" */ + 0x0, 0x0, 0x28, 0x40, 0x0, 0x0, 0x0, 0xa, + 0xfe, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x8f, 0x8f, 0xc0, 0x0, 0x0, 0xe, + 0xf0, 0xbf, 0x30, 0x0, 0x6, 0xf9, 0x5, 0xfa, + 0x0, 0x0, 0xdf, 0x20, 0xe, 0xf1, 0x0, 0x4f, + 0xc0, 0x0, 0x8f, 0x80, 0xb, 0xf6, 0x0, 0x1, + 0xfe, 0x2, 0xff, 0x0, 0x0, 0xb, 0xf6, + + /* U+005F "_" */ + 0x19, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x42, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, + + /* U+0060 "`" */ + 0x45, 0x50, 0x4, 0xff, 0x40, 0x7, 0xfb, 0x0, + 0xa, 0xf3, + + /* U+0061 "a" */ + 0x0, 0x4, 0xbe, 0xff, 0xd8, 0x10, 0x0, 0x9, + 0xff, 0xec, 0xdf, 0xfe, 0x10, 0x4, 0xff, 0x40, + 0x0, 0x2e, 0xf7, 0x0, 0x8f, 0x90, 0x0, 0x0, + 0x8f, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xfb, + 0x0, 0x0, 0x3, 0x68, 0xad, 0xff, 0xb0, 0x0, + 0x6e, 0xff, 0xff, 0xdc, 0xfb, 0x0, 0x7f, 0xfa, + 0x63, 0x0, 0x7f, 0xb0, 0xf, 0xf7, 0x0, 0x0, + 0x8, 0xfb, 0x0, 0xff, 0x30, 0x0, 0x0, 0xdf, + 0xb0, 0xe, 0xfa, 0x0, 0x1, 0xbf, 0xfc, 0x0, + 0x6f, 0xfe, 0xbc, 0xff, 0xcf, 0xd0, 0x0, 0x4b, + 0xef, 0xea, 0x40, 0xff, 0x20, + + /* U+0062 "b" */ + 0x6f, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xb2, + 0xae, 0xfc, 0x60, 0x0, 0x6f, 0xde, 0xfd, 0xdf, + 0xfa, 0x0, 0x6f, 0xfd, 0x20, 0x3, 0xef, 0x70, + 0x6f, 0xf4, 0x0, 0x0, 0x6f, 0xe0, 0x6f, 0xd0, + 0x0, 0x0, 0xf, 0xf3, 0x6f, 0xa0, 0x0, 0x0, + 0xd, 0xf5, 0x6f, 0x80, 0x0, 0x0, 0xc, 0xf6, + 0x6f, 0x90, 0x0, 0x0, 0xd, 0xf5, 0x6f, 0xb0, + 0x0, 0x0, 0x1f, 0xf2, 0x6f, 0xf2, 0x0, 0x0, + 0x7f, 0xd0, 0x6f, 0xfd, 0x20, 0x4, 0xff, 0x50, + 0x6f, 0xbf, 0xfd, 0xdf, 0xf8, 0x0, 0x6f, 0x92, + 0xbf, 0xfc, 0x50, 0x0, + + /* U+0063 "c" */ + 0x0, 0x2, 0xae, 0xfe, 0xa3, 0x0, 0x0, 0x5f, + 0xff, 0xce, 0xff, 0x60, 0x2, 0xff, 0x80, 0x0, + 0x7f, 0xf2, 0x9, 0xfb, 0x0, 0x0, 0xc, 0xf7, + 0xd, 0xf5, 0x0, 0x0, 0x1, 0x10, 0xf, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xf5, 0x0, 0x0, 0x5, 0xc7, 0x9, 0xfa, + 0x0, 0x0, 0xb, 0xf8, 0x2, 0xff, 0x70, 0x0, + 0x7f, 0xf1, 0x0, 0x5f, 0xfe, 0xce, 0xff, 0x50, + 0x0, 0x2, 0xae, 0xfe, 0xa2, 0x0, + + /* U+0064 "d" */ + 0x0, 0x0, 0x0, 0x0, 0x7, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x7, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xfa, 0x0, 0x4, + 0xbf, 0xfc, 0x47, 0xfa, 0x0, 0x6f, 0xfe, 0xdf, + 0xfc, 0xfa, 0x2, 0xff, 0x70, 0x0, 0xbf, 0xfa, + 0xa, 0xfb, 0x0, 0x0, 0xe, 0xfa, 0xe, 0xf4, + 0x0, 0x0, 0x9, 0xfa, 0xf, 0xf2, 0x0, 0x0, + 0x6, 0xfa, 0x1f, 0xf0, 0x0, 0x0, 0x4, 0xfa, + 0xf, 0xf2, 0x0, 0x0, 0x5, 0xfa, 0xe, 0xf4, + 0x0, 0x0, 0x7, 0xfa, 0x9, 0xfb, 0x0, 0x0, + 0xd, 0xfa, 0x2, 0xff, 0x70, 0x0, 0xaf, 0xfa, + 0x0, 0x5f, 0xfe, 0xcf, 0xfb, 0xfa, 0x0, 0x3, + 0xae, 0xfc, 0x54, 0xfa, + + /* U+0065 "e" */ + 0x0, 0x1, 0x9d, 0xfe, 0xb4, 0x0, 0x0, 0x3, + 0xff, 0xfc, 0xef, 0xf9, 0x0, 0x1, 0xef, 0x90, + 0x0, 0x4e, 0xf6, 0x0, 0x8f, 0xc0, 0x0, 0x0, + 0x5f, 0xe0, 0xd, 0xf6, 0x0, 0x0, 0x0, 0xff, + 0x20, 0xff, 0xdc, 0xcc, 0xcc, 0xcf, 0xf5, 0xf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xf6, 0x0, 0x0, + 0x0, 0x42, 0x0, 0x9f, 0xd0, 0x0, 0x0, 0x3f, + 0xf1, 0x2, 0xff, 0xa1, 0x0, 0x3e, 0xfa, 0x0, + 0x4, 0xff, 0xfc, 0xdf, 0xfc, 0x0, 0x0, 0x2, + 0x9d, 0xff, 0xc7, 0x0, 0x0, + + /* U+0066 "f" */ + 0x0, 0x8, 0xef, 0xe5, 0x0, 0x8f, 0xff, 0xf4, + 0x0, 0xdf, 0x90, 0x0, 0x0, 0xff, 0x30, 0x0, + 0x0, 0xff, 0x20, 0x0, 0xdf, 0xff, 0xff, 0x90, + 0x8a, 0xff, 0xba, 0x60, 0x0, 0xff, 0x20, 0x0, + 0x0, 0xff, 0x20, 0x0, 0x0, 0xff, 0x20, 0x0, + 0x0, 0xff, 0x20, 0x0, 0x0, 0xff, 0x20, 0x0, + 0x0, 0xff, 0x20, 0x0, 0x0, 0xff, 0x20, 0x0, + 0x0, 0xff, 0x20, 0x0, 0x0, 0xff, 0x20, 0x0, + 0x0, 0xff, 0x20, 0x0, 0x0, 0xff, 0x20, 0x0, + + /* U+0067 "g" */ + 0x0, 0x4, 0xbe, 0xfc, 0x52, 0xfc, 0x0, 0x6f, + 0xfe, 0xcf, 0xfa, 0xfc, 0x2, 0xff, 0x70, 0x0, + 0xaf, 0xfc, 0xa, 0xfa, 0x0, 0x0, 0xe, 0xfc, + 0xe, 0xf4, 0x0, 0x0, 0x7, 0xfc, 0x1f, 0xf1, + 0x0, 0x0, 0x4, 0xfc, 0x2f, 0xf0, 0x0, 0x0, + 0x3, 0xfc, 0x1f, 0xf0, 0x0, 0x0, 0x3, 0xfc, + 0xe, 0xf3, 0x0, 0x0, 0x6, 0xfc, 0xa, 0xf9, + 0x0, 0x0, 0xc, 0xfc, 0x2, 0xff, 0x70, 0x0, + 0x9f, 0xfc, 0x0, 0x6f, 0xfe, 0xcf, 0xfc, 0xfc, + 0x0, 0x4, 0xbe, 0xfc, 0x56, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xfa, 0xa, 0xd4, 0x0, 0x0, + 0xb, 0xf7, 0x7, 0xfd, 0x10, 0x0, 0x7f, 0xf1, + 0x1, 0xdf, 0xfd, 0xdf, 0xff, 0x50, 0x0, 0x18, + 0xdf, 0xfd, 0x92, 0x0, + + /* U+0068 "h" */ + 0x6f, 0xb0, 0x0, 0x0, 0x0, 0x6, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xb0, 0x0, 0x0, 0x0, + 0x6, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xb0, + 0x0, 0x0, 0x0, 0x6, 0xfb, 0x19, 0xef, 0xe9, + 0x10, 0x6f, 0xde, 0xfe, 0xef, 0xfd, 0x6, 0xff, + 0xd4, 0x0, 0x4f, 0xf6, 0x6f, 0xf3, 0x0, 0x0, + 0x9f, 0xa6, 0xfe, 0x0, 0x0, 0x6, 0xfb, 0x6f, + 0xc0, 0x0, 0x0, 0x5f, 0xc6, 0xfb, 0x0, 0x0, + 0x5, 0xfc, 0x6f, 0xb0, 0x0, 0x0, 0x5f, 0xc6, + 0xfb, 0x0, 0x0, 0x5, 0xfc, 0x6f, 0xb0, 0x0, + 0x0, 0x5f, 0xc6, 0xfb, 0x0, 0x0, 0x5, 0xfc, + 0x6f, 0xb0, 0x0, 0x0, 0x5f, 0xc6, 0xfb, 0x0, + 0x0, 0x5, 0xfc, + + /* U+0069 "i" */ + 0x6f, 0xb6, 0xfb, 0x27, 0x50, 0x0, 0x0, 0x6, + 0xfb, 0x6f, 0xb6, 0xfb, 0x6f, 0xb6, 0xfb, 0x6f, + 0xb6, 0xfb, 0x6f, 0xb6, 0xfb, 0x6f, 0xb6, 0xfb, + 0x6f, 0xb6, 0xfb, + + /* U+006A "j" */ + 0x0, 0x6, 0xfb, 0x0, 0x6, 0xfb, 0x0, 0x3, + 0x85, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xfb, 0x0, 0x6, 0xfb, 0x0, 0x6, 0xfb, + 0x0, 0x6, 0xfb, 0x0, 0x6, 0xfb, 0x0, 0x6, + 0xfb, 0x0, 0x6, 0xfb, 0x0, 0x6, 0xfb, 0x0, + 0x6, 0xfb, 0x0, 0x6, 0xfb, 0x0, 0x6, 0xfb, + 0x0, 0x6, 0xfb, 0x0, 0x6, 0xfb, 0x0, 0x6, + 0xfb, 0x0, 0x6, 0xfb, 0x0, 0xa, 0xf8, 0xc, + 0xff, 0xf3, 0xd, 0xfe, 0x70, + + /* U+006B "k" */ + 0x6f, 0xb0, 0x0, 0x0, 0x0, 0x6, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xb0, 0x0, 0x0, 0x0, + 0x6, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xb0, + 0x0, 0x0, 0x0, 0x6, 0xfb, 0x0, 0x0, 0xbf, + 0xd1, 0x6f, 0xb0, 0x0, 0xbf, 0xd1, 0x6, 0xfb, + 0x0, 0xaf, 0xd1, 0x0, 0x6f, 0xb0, 0x9f, 0xd1, + 0x0, 0x6, 0xfb, 0x8f, 0xe1, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0x20, 0x0, 0x6, 0xff, 0xec, 0xfb, + 0x0, 0x0, 0x6f, 0xe2, 0x2f, 0xf6, 0x0, 0x6, + 0xfb, 0x0, 0x7f, 0xe1, 0x0, 0x6f, 0xb0, 0x0, + 0xdf, 0xa0, 0x6, 0xfb, 0x0, 0x3, 0xff, 0x40, + 0x6f, 0xb0, 0x0, 0x9, 0xfe, 0x6, 0xfb, 0x0, + 0x0, 0x1e, 0xf9, + + /* U+006C "l" */ + 0x6f, 0xb6, 0xfb, 0x6f, 0xb6, 0xfb, 0x6f, 0xb6, + 0xfb, 0x6f, 0xb6, 0xfb, 0x6f, 0xb6, 0xfb, 0x6f, + 0xb6, 0xfb, 0x6f, 0xb6, 0xfb, 0x6f, 0xb6, 0xfb, + 0x6f, 0xb6, 0xfb, + + /* U+006D "m" */ + 0x6f, 0x72, 0xae, 0xfd, 0x50, 0x6, 0xdf, 0xe9, + 0x10, 0x6f, 0x9e, 0xfe, 0xff, 0xf5, 0xaf, 0xfe, + 0xff, 0xc0, 0x6f, 0xfc, 0x20, 0xb, 0xff, 0xf5, + 0x0, 0x5f, 0xf3, 0x6f, 0xf2, 0x0, 0x3, 0xff, + 0x70, 0x0, 0xd, 0xf6, 0x6f, 0xd0, 0x0, 0x1, + 0xff, 0x20, 0x0, 0xb, 0xf6, 0x6f, 0xb0, 0x0, + 0x0, 0xff, 0x10, 0x0, 0xa, 0xf7, 0x6f, 0xb0, + 0x0, 0x0, 0xff, 0x10, 0x0, 0xa, 0xf7, 0x6f, + 0xb0, 0x0, 0x0, 0xff, 0x10, 0x0, 0xa, 0xf7, + 0x6f, 0xb0, 0x0, 0x0, 0xff, 0x10, 0x0, 0xa, + 0xf7, 0x6f, 0xb0, 0x0, 0x0, 0xff, 0x10, 0x0, + 0xa, 0xf7, 0x6f, 0xb0, 0x0, 0x0, 0xff, 0x10, + 0x0, 0xa, 0xf7, 0x6f, 0xb0, 0x0, 0x0, 0xff, + 0x10, 0x0, 0xa, 0xf7, 0x6f, 0xb0, 0x0, 0x0, + 0xff, 0x10, 0x0, 0xa, 0xf7, + + /* U+006E "n" */ + 0x6f, 0x81, 0x9e, 0xfe, 0x91, 0x6, 0xf9, 0xef, + 0xff, 0xff, 0xd0, 0x6f, 0xfd, 0x40, 0x4, 0xff, + 0x66, 0xff, 0x30, 0x0, 0x9, 0xfa, 0x6f, 0xe0, + 0x0, 0x0, 0x6f, 0xb6, 0xfc, 0x0, 0x0, 0x5, + 0xfb, 0x6f, 0xb0, 0x0, 0x0, 0x5f, 0xc6, 0xfb, + 0x0, 0x0, 0x5, 0xfc, 0x6f, 0xb0, 0x0, 0x0, + 0x5f, 0xc6, 0xfb, 0x0, 0x0, 0x5, 0xfc, 0x6f, + 0xb0, 0x0, 0x0, 0x5f, 0xc6, 0xfb, 0x0, 0x0, + 0x5, 0xfc, 0x6f, 0xb0, 0x0, 0x0, 0x5f, 0xc0, + + /* U+006F "o" */ + 0x0, 0x2, 0x9d, 0xfe, 0xb5, 0x0, 0x0, 0x5, + 0xff, 0xfc, 0xef, 0xfa, 0x0, 0x3, 0xff, 0x90, + 0x0, 0x4f, 0xf7, 0x0, 0xaf, 0xb0, 0x0, 0x0, + 0x5f, 0xf0, 0xf, 0xf4, 0x0, 0x0, 0x0, 0xef, + 0x41, 0xff, 0x10, 0x0, 0x0, 0xb, 0xf6, 0x2f, + 0xf0, 0x0, 0x0, 0x0, 0xaf, 0x71, 0xff, 0x10, + 0x0, 0x0, 0xb, 0xf6, 0xe, 0xf4, 0x0, 0x0, + 0x0, 0xef, 0x40, 0xaf, 0xb0, 0x0, 0x0, 0x5f, + 0xf0, 0x3, 0xff, 0x90, 0x0, 0x4f, 0xf7, 0x0, + 0x5, 0xff, 0xfc, 0xef, 0xfa, 0x0, 0x0, 0x2, + 0x9e, 0xfe, 0xb5, 0x0, 0x0, + + /* U+0070 "p" */ + 0x6f, 0x82, 0xae, 0xfd, 0x60, 0x0, 0x6f, 0xbe, + 0xfb, 0xbf, 0xfb, 0x0, 0x6f, 0xfe, 0x20, 0x2, + 0xef, 0x70, 0x6f, 0xf4, 0x0, 0x0, 0x6f, 0xe0, + 0x6f, 0xd0, 0x0, 0x0, 0xf, 0xf3, 0x6f, 0xa0, + 0x0, 0x0, 0xd, 0xf6, 0x6f, 0x90, 0x0, 0x0, + 0xb, 0xf6, 0x6f, 0xa0, 0x0, 0x0, 0xc, 0xf5, + 0x6f, 0xc0, 0x0, 0x0, 0xf, 0xf2, 0x6f, 0xf3, + 0x0, 0x0, 0x6f, 0xd0, 0x6f, 0xfd, 0x10, 0x4, + 0xff, 0x50, 0x6f, 0xef, 0xfc, 0xdf, 0xf9, 0x0, + 0x6f, 0xb2, 0xbf, 0xfc, 0x50, 0x0, 0x6f, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xb0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0071 "q" */ + 0x0, 0x4, 0xbe, 0xfc, 0x43, 0xfa, 0x0, 0x6f, + 0xfd, 0xbe, 0xf9, 0xfa, 0x2, 0xff, 0x60, 0x0, + 0xaf, 0xfa, 0xa, 0xfb, 0x0, 0x0, 0xe, 0xfa, + 0xe, 0xf4, 0x0, 0x0, 0x8, 0xfa, 0xf, 0xf2, + 0x0, 0x0, 0x5, 0xfa, 0x1f, 0xf1, 0x0, 0x0, + 0x3, 0xfa, 0xf, 0xf2, 0x0, 0x0, 0x4, 0xfa, + 0xd, 0xf5, 0x0, 0x0, 0x7, 0xfa, 0x8, 0xfc, + 0x0, 0x0, 0xd, 0xfa, 0x1, 0xef, 0x80, 0x0, + 0x9f, 0xfa, 0x0, 0x4f, 0xfe, 0xcf, 0xfd, 0xfa, + 0x0, 0x2, 0xae, 0xfc, 0x57, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x7, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xfa, + + /* U+0072 "r" */ + 0x7f, 0x74, 0xdf, 0xc2, 0x7f, 0x9f, 0xff, 0xf0, + 0x7f, 0xfd, 0x54, 0x60, 0x7f, 0xf2, 0x0, 0x0, + 0x7f, 0xd0, 0x0, 0x0, 0x7f, 0xb0, 0x0, 0x0, + 0x7f, 0xa0, 0x0, 0x0, 0x7f, 0xa0, 0x0, 0x0, + 0x7f, 0xa0, 0x0, 0x0, 0x7f, 0xa0, 0x0, 0x0, + 0x7f, 0xa0, 0x0, 0x0, 0x7f, 0xa0, 0x0, 0x0, + 0x7f, 0xa0, 0x0, 0x0, + + /* U+0073 "s" */ + 0x0, 0x19, 0xdf, 0xec, 0x60, 0x0, 0x3, 0xff, + 0xec, 0xdf, 0xfc, 0x0, 0xb, 0xf8, 0x0, 0x3, + 0xef, 0x50, 0xe, 0xf2, 0x0, 0x0, 0x7a, 0x40, + 0xb, 0xfc, 0x40, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xfe, 0xa6, 0x10, 0x0, 0x0, 0x2a, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x4, 0x8d, 0xff, 0xa0, + 0x2, 0x30, 0x0, 0x0, 0x6f, 0xf0, 0x1f, 0xf1, + 0x0, 0x0, 0x2f, 0xf0, 0xb, 0xfb, 0x10, 0x1, + 0xbf, 0xc0, 0x1, 0xef, 0xfd, 0xdf, 0xfe, 0x20, + 0x0, 0x18, 0xde, 0xfd, 0x91, 0x0, + + /* U+0074 "t" */ + 0x0, 0x2, 0x0, 0x0, 0x7, 0xf0, 0x0, 0x1, + 0xff, 0x0, 0x0, 0x1f, 0xf0, 0x0, 0x1, 0xff, + 0x0, 0x9, 0xff, 0xff, 0xf2, 0x6b, 0xff, 0xaa, + 0x10, 0x1f, 0xf0, 0x0, 0x1, 0xff, 0x0, 0x0, + 0x1f, 0xf0, 0x0, 0x1, 0xff, 0x0, 0x0, 0x1f, + 0xf0, 0x0, 0x1, 0xff, 0x0, 0x0, 0x1f, 0xf0, + 0x0, 0x0, 0xff, 0x0, 0x0, 0xf, 0xf5, 0x0, + 0x0, 0xdf, 0xff, 0x30, 0x3, 0xcf, 0xe5, + + /* U+0075 "u" */ + 0x6f, 0xb0, 0x0, 0x0, 0x7f, 0xa6, 0xfb, 0x0, + 0x0, 0x7, 0xfa, 0x6f, 0xb0, 0x0, 0x0, 0x7f, + 0xa6, 0xfb, 0x0, 0x0, 0x7, 0xfa, 0x6f, 0xb0, + 0x0, 0x0, 0x7f, 0xa6, 0xfb, 0x0, 0x0, 0x7, + 0xfa, 0x6f, 0xb0, 0x0, 0x0, 0x7f, 0xa6, 0xfb, + 0x0, 0x0, 0x7, 0xfa, 0x6f, 0xb0, 0x0, 0x0, + 0x9f, 0xa5, 0xfe, 0x0, 0x0, 0xe, 0xfa, 0x1f, + 0xf8, 0x0, 0x1b, 0xff, 0xa0, 0x8f, 0xff, 0xef, + 0xf7, 0xfa, 0x0, 0x6c, 0xfe, 0xa2, 0x3f, 0xa0, + + /* U+0076 "v" */ + 0x8f, 0xb0, 0x0, 0x0, 0xa, 0xf8, 0x2f, 0xf1, + 0x0, 0x0, 0xf, 0xf2, 0xc, 0xf6, 0x0, 0x0, + 0x5f, 0xd0, 0x6, 0xfb, 0x0, 0x0, 0xaf, 0x70, + 0x1, 0xff, 0x10, 0x0, 0xff, 0x10, 0x0, 0xaf, + 0x60, 0x6, 0xfb, 0x0, 0x0, 0x5f, 0xc0, 0xb, + 0xf5, 0x0, 0x0, 0xe, 0xf1, 0x1f, 0xf0, 0x0, + 0x0, 0x9, 0xf6, 0x6f, 0xa0, 0x0, 0x0, 0x3, + 0xfb, 0xbf, 0x40, 0x0, 0x0, 0x0, 0xdf, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xf3, 0x0, 0x0, + + /* U+0077 "w" */ + 0xbf, 0x60, 0x0, 0x7, 0xfe, 0x0, 0x0, 0xf, + 0xf0, 0x7f, 0xb0, 0x0, 0xc, 0xff, 0x20, 0x0, + 0x4f, 0xb0, 0x2f, 0xf0, 0x0, 0xf, 0xff, 0x60, + 0x0, 0x9f, 0x70, 0xd, 0xf3, 0x0, 0x4f, 0xcf, + 0xa0, 0x0, 0xdf, 0x20, 0x9, 0xf7, 0x0, 0x8f, + 0x5f, 0xe0, 0x2, 0xfd, 0x0, 0x4, 0xfc, 0x0, + 0xcf, 0xc, 0xf2, 0x6, 0xf8, 0x0, 0x0, 0xff, + 0x1, 0xfc, 0x8, 0xf6, 0xb, 0xf3, 0x0, 0x0, + 0xaf, 0x45, 0xf8, 0x4, 0xfa, 0xf, 0xe0, 0x0, + 0x0, 0x6f, 0x88, 0xf4, 0x0, 0xfe, 0x4f, 0xa0, + 0x0, 0x0, 0x1f, 0xcc, 0xf0, 0x0, 0xcf, 0xbf, + 0x50, 0x0, 0x0, 0xc, 0xff, 0xc0, 0x0, 0x8f, + 0xff, 0x0, 0x0, 0x0, 0x8, 0xff, 0x80, 0x0, + 0x4f, 0xfb, 0x0, 0x0, 0x0, 0x3, 0xff, 0x40, + 0x0, 0xf, 0xf7, 0x0, 0x0, + + /* U+0078 "x" */ + 0x2f, 0xf7, 0x0, 0x0, 0x5f, 0xf2, 0x7, 0xff, + 0x20, 0x1, 0xef, 0x70, 0x0, 0xcf, 0xb0, 0xb, + 0xfb, 0x0, 0x0, 0x2f, 0xf5, 0x6f, 0xe1, 0x0, + 0x0, 0x7, 0xfe, 0xff, 0x50, 0x0, 0x0, 0x0, + 0xcf, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf7, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x20, 0x0, + 0x0, 0xc, 0xf9, 0x9f, 0xc0, 0x0, 0x0, 0x7f, + 0xe1, 0x1e, 0xf7, 0x0, 0x2, 0xff, 0x50, 0x5, + 0xff, 0x20, 0xc, 0xfb, 0x0, 0x0, 0xbf, 0xc0, + 0x7f, 0xf1, 0x0, 0x0, 0x2f, 0xf7, + + /* U+0079 "y" */ + 0x6f, 0xd0, 0x0, 0x0, 0x7, 0xf9, 0x1f, 0xf2, + 0x0, 0x0, 0xd, 0xf3, 0xb, 0xf8, 0x0, 0x0, + 0x3f, 0xe0, 0x5, 0xfd, 0x0, 0x0, 0x9f, 0x80, + 0x0, 0xef, 0x30, 0x0, 0xef, 0x20, 0x0, 0x9f, + 0x90, 0x4, 0xfc, 0x0, 0x0, 0x3f, 0xe0, 0xa, + 0xf6, 0x0, 0x0, 0xd, 0xf4, 0xf, 0xf1, 0x0, + 0x0, 0x7, 0xf9, 0x4f, 0xb0, 0x0, 0x0, 0x2, + 0xfe, 0x9f, 0x50, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0x70, + 0x0, 0x0, 0x2, 0x25, 0xff, 0x10, 0x0, 0x0, + 0xa, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x7, 0xfe, + 0x80, 0x0, 0x0, 0x0, + + /* U+007A "z" */ + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xb, 0xbb, + 0xbb, 0xbb, 0xef, 0xe0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x2f, 0xf6, 0x0, + 0x0, 0x0, 0x1, 0xdf, 0x90, 0x0, 0x0, 0x0, + 0xb, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xe1, + 0x0, 0x0, 0x0, 0x6, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x4f, 0xf6, 0x0, 0x0, 0x0, 0x2, 0xef, + 0x80, 0x0, 0x0, 0x0, 0x1d, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xfc, 0xcd, 0xdd, 0xdd, 0xd6, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xf7, + + /* U+007B "{" */ + 0x0, 0x0, 0x6d, 0xf7, 0x0, 0x4, 0xff, 0xf6, + 0x0, 0xa, 0xf8, 0x0, 0x0, 0xc, 0xf2, 0x0, + 0x0, 0xd, 0xf1, 0x0, 0x0, 0xe, 0xf1, 0x0, + 0x0, 0xe, 0xf1, 0x0, 0x0, 0xe, 0xf0, 0x0, + 0x0, 0xf, 0xf0, 0x0, 0x0, 0x3f, 0xc0, 0x0, + 0x2, 0xdf, 0x50, 0x0, 0x5f, 0xf6, 0x0, 0x0, + 0x4f, 0xf7, 0x0, 0x0, 0x2, 0xcf, 0x60, 0x0, + 0x0, 0x3f, 0xd0, 0x0, 0x0, 0xf, 0xf0, 0x0, + 0x0, 0xe, 0xf1, 0x0, 0x0, 0xe, 0xf1, 0x0, + 0x0, 0xd, 0xf1, 0x0, 0x0, 0xd, 0xf2, 0x0, + 0x0, 0xb, 0xf6, 0x0, 0x0, 0x5, 0xff, 0xe6, + 0x0, 0x0, 0x7e, 0xf7, + + /* U+007C "|" */ + 0xcf, 0xc, 0xf0, 0xcf, 0xc, 0xf0, 0xcf, 0xc, + 0xf0, 0xcf, 0xc, 0xf0, 0xcf, 0xc, 0xf0, 0xcf, + 0xc, 0xf0, 0xcf, 0xc, 0xf0, 0xcf, 0xc, 0xf0, + 0xcf, 0xc, 0xf0, 0xcf, 0xc, 0xf0, 0xcf, 0xc, + 0xf0, 0xcf, 0x0, + + /* U+007D "}" */ + 0x7f, 0xd6, 0x0, 0x0, 0x6f, 0xff, 0x40, 0x0, + 0x0, 0x7f, 0xa0, 0x0, 0x0, 0x2f, 0xc0, 0x0, + 0x0, 0x1f, 0xd0, 0x0, 0x0, 0x1f, 0xe0, 0x0, + 0x0, 0xf, 0xe0, 0x0, 0x0, 0xf, 0xf0, 0x0, + 0x0, 0xe, 0xf0, 0x0, 0x0, 0xb, 0xf4, 0x0, + 0x0, 0x4, 0xfc, 0x20, 0x0, 0x0, 0x5f, 0xf5, + 0x0, 0x0, 0x7f, 0xf5, 0x0, 0x6, 0xfc, 0x20, + 0x0, 0xd, 0xf3, 0x0, 0x0, 0xf, 0xf0, 0x0, + 0x0, 0xf, 0xe0, 0x0, 0x0, 0xf, 0xe0, 0x0, + 0x0, 0xf, 0xe0, 0x0, 0x0, 0x1f, 0xd0, 0x0, + 0x0, 0x6f, 0xb0, 0x0, 0x6e, 0xff, 0x60, 0x0, + 0x7f, 0xd7, 0x0, 0x0, + + /* U+007E "~" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x9e, + 0xfc, 0x71, 0x0, 0x0, 0x80, 0xdf, 0xff, 0xff, + 0xfa, 0x55, 0xbf, 0xf, 0xb5, 0x59, 0xff, 0xff, + 0xff, 0xe0, 0x80, 0x0, 0x1, 0x7c, 0xfe, 0x91, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00A0 " " */ + + /* U+00A3 "£" */ + 0x0, 0x0, 0x6c, 0xff, 0xd7, 0x0, 0x0, 0x0, + 0xcf, 0xfe, 0xdf, 0xfd, 0x10, 0x0, 0xaf, 0xe3, + 0x0, 0x3e, 0xfa, 0x0, 0xf, 0xf5, 0x0, 0x0, + 0x3f, 0xf1, 0x3, 0xff, 0x0, 0x0, 0x0, 0xa9, + 0x10, 0x2f, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xc, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x5, 0xcc, 0xff, 0xcc, 0xc4, 0x0, + 0x0, 0x0, 0xf, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xee, 0x10, 0x0, 0x0, + 0x0, 0x2, 0xdf, 0xcb, 0xb9, 0x63, 0x12, 0x71, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x71, 0xd6, + 0x20, 0x14, 0x8c, 0xfe, 0xb4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+00A4 "¤" */ + 0x2, 0x70, 0x0, 0x0, 0x0, 0x45, 0x0, 0xdf, + 0x86, 0xdf, 0xe9, 0x5f, 0xf3, 0x3, 0xff, 0xff, + 0xff, 0xff, 0xf8, 0x0, 0x9, 0xfd, 0x30, 0x2a, + 0xff, 0x0, 0x0, 0xff, 0x10, 0x0, 0xc, 0xf5, + 0x0, 0x3f, 0xb0, 0x0, 0x0, 0x6f, 0x90, 0x3, + 0xfb, 0x0, 0x0, 0x6, 0xf9, 0x0, 0xf, 0xf1, + 0x0, 0x0, 0xcf, 0x50, 0x0, 0x9f, 0xd3, 0x2, + 0xaf, 0xf0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, + 0x80, 0xd, 0xf8, 0x6d, 0xfe, 0x95, 0xff, 0x30, + 0x27, 0x0, 0x0, 0x0, 0x4, 0x50, + + /* U+00A5 "¥" */ + 0xbf, 0x90, 0x0, 0x0, 0x0, 0x7f, 0xf1, 0x3f, + 0xf2, 0x0, 0x0, 0x0, 0xef, 0x80, 0xa, 0xfa, + 0x0, 0x0, 0x7, 0xff, 0x10, 0x2, 0xff, 0x20, + 0x0, 0xe, 0xf7, 0x0, 0x0, 0x9f, 0xb0, 0x0, + 0x6f, 0xe0, 0x0, 0x0, 0x1f, 0xf3, 0x0, 0xef, + 0x60, 0x0, 0x0, 0x8, 0xfb, 0x6, 0xfd, 0x0, + 0x0, 0x0, 0x1, 0xff, 0x3e, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xef, 0xd0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x2c, 0xcc, + 0xcd, 0xff, 0xcc, 0xcc, 0x70, 0x0, 0x0, 0x5, + 0xfc, 0x0, 0x0, 0x0, 0x2a, 0xaa, 0xac, 0xfe, + 0xaa, 0xaa, 0x60, 0x3f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x5, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xfc, 0x0, 0x0, 0x0, + + /* U+00A6 "¦" */ + 0xcf, 0xc, 0xf0, 0xcf, 0xc, 0xf0, 0xcf, 0xc, + 0xf0, 0xcf, 0xc, 0xf0, 0xcf, 0x5, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x5, 0x70, 0xcf, 0xc, 0xf0, + 0xcf, 0xc, 0xf0, 0xcf, 0xc, 0xf0, 0xcf, 0xc, + 0xf0, 0xcf, 0x0, + + /* U+00A7 "§" */ + 0x0, 0x19, 0xef, 0xea, 0x30, 0x0, 0x1, 0xef, + 0xfd, 0xff, 0xf3, 0x0, 0x9, 0xfb, 0x10, 0xb, + 0xfd, 0x0, 0xd, 0xf4, 0x0, 0x2, 0xff, 0x20, + 0xc, 0xf7, 0x0, 0x0, 0x53, 0x0, 0x5, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfa, 0x10, + 0x0, 0x0, 0xa, 0xfc, 0xff, 0xe5, 0x0, 0x0, + 0x8f, 0x80, 0x3d, 0xff, 0xa1, 0x0, 0xef, 0x0, + 0x0, 0x8f, 0xfd, 0x20, 0xff, 0x0, 0x0, 0x3, + 0xef, 0xc0, 0xbf, 0x90, 0x0, 0x0, 0x3f, 0xf2, + 0x3f, 0xfb, 0x10, 0x0, 0xc, 0xf4, 0x4, 0xef, + 0xf7, 0x0, 0xe, 0xf1, 0x0, 0x1b, 0xff, 0xc3, + 0xbf, 0x70, 0x0, 0x0, 0x6e, 0xff, 0xe4, 0x0, + 0x0, 0x0, 0x1, 0xbf, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0x20, 0x16, 0x80, 0x0, 0x0, + 0xcf, 0x60, 0x1f, 0xf3, 0x0, 0x0, 0xbf, 0x70, + 0xb, 0xfd, 0x20, 0x5, 0xff, 0x30, 0x2, 0xef, + 0xfd, 0xef, 0xf8, 0x0, 0x0, 0x18, 0xdf, 0xfc, + 0x50, 0x0, + + /* U+00A8 "¨" */ + 0x27, 0x60, 0x6, 0x72, 0x4f, 0xe0, 0xe, 0xf4, + 0x4f, 0xe0, 0xe, 0xf4, + + /* U+00A9 "©" */ + 0x0, 0x0, 0x4, 0xad, 0xfe, 0xd8, 0x30, 0x0, + 0x0, 0x0, 0x3, 0xcf, 0xea, 0x89, 0xbf, 0xfa, + 0x0, 0x0, 0x0, 0x4f, 0xe5, 0x0, 0x0, 0x1, + 0x8f, 0xc1, 0x0, 0x2, 0xfc, 0x10, 0x0, 0x0, + 0x0, 0x4, 0xfc, 0x0, 0xc, 0xe1, 0x0, 0x7d, + 0xff, 0xc4, 0x0, 0x5f, 0x70, 0x4f, 0x50, 0xa, + 0xf9, 0x55, 0xcf, 0x40, 0xa, 0xf0, 0xae, 0x0, + 0x4f, 0x90, 0x0, 0xc, 0xb0, 0x3, 0xf5, 0xda, + 0x0, 0x9f, 0x10, 0x0, 0x0, 0x0, 0x0, 0xf8, + 0xf8, 0x0, 0xbe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xda, 0xf8, 0x0, 0xcd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xda, 0xda, 0x0, 0xaf, 0x0, 0x0, 0x2, + 0x20, 0x0, 0xe8, 0xae, 0x0, 0x5f, 0x60, 0x0, + 0xb, 0xe0, 0x3, 0xf5, 0x4f, 0x50, 0xc, 0xf7, + 0x23, 0xaf, 0x60, 0xa, 0xe0, 0xc, 0xe1, 0x1, + 0xbf, 0xff, 0xe6, 0x0, 0x4f, 0x70, 0x2, 0xfc, + 0x10, 0x1, 0x33, 0x0, 0x3, 0xfc, 0x0, 0x0, + 0x4f, 0xe5, 0x0, 0x0, 0x0, 0x7f, 0xd1, 0x0, + 0x0, 0x2, 0xcf, 0xea, 0x88, 0xbf, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xad, 0xff, 0xd9, 0x30, + 0x0, 0x0, + + /* U+00AA "ª" */ + 0x2, 0xbf, 0xe9, 0x3f, 0x80, 0xef, 0x75, 0xde, + 0xf3, 0x6f, 0x70, 0x1, 0xff, 0x9, 0xf3, 0x0, + 0xd, 0xb0, 0x9f, 0x30, 0x0, 0xdb, 0x6, 0xf7, + 0x0, 0x2f, 0xe0, 0xd, 0xf7, 0x6d, 0xef, 0x30, + 0x2b, 0xff, 0xa3, 0xf8, + + /* U+00AB "«" */ + 0x0, 0x0, 0xcc, 0x0, 0x6e, 0x50, 0x0, 0x9f, + 0x40, 0x1f, 0xd0, 0x0, 0x4f, 0xb0, 0xb, 0xf4, + 0x0, 0x1e, 0xf3, 0x6, 0xfb, 0x0, 0xa, 0xf9, + 0x2, 0xff, 0x20, 0x3, 0xff, 0x20, 0x9f, 0xb0, + 0x0, 0xb, 0xf8, 0x2, 0xff, 0x20, 0x0, 0x1e, + 0xf2, 0x7, 0xfa, 0x0, 0x0, 0x5f, 0xa0, 0xc, + 0xf3, 0x0, 0x0, 0xaf, 0x30, 0x2f, 0xc0, 0x0, + 0x1, 0xec, 0x0, 0x7f, 0x50, + + /* U+00AC "¬" */ + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x5, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00AD "­" */ + 0x2, 0x22, 0x22, 0x20, 0x3f, 0xff, 0xff, 0xf4, + 0x3f, 0xff, 0xff, 0xf4, + + /* U+00AE "®" */ + 0x0, 0x0, 0x4, 0xad, 0xfe, 0xd8, 0x30, 0x0, + 0x0, 0x0, 0x3, 0xcf, 0xea, 0x89, 0xbf, 0xfa, + 0x0, 0x0, 0x0, 0x4f, 0xe5, 0x0, 0x0, 0x1, + 0x8f, 0xc1, 0x0, 0x2, 0xfc, 0x11, 0x11, 0x0, + 0x0, 0x4, 0xfc, 0x0, 0xc, 0xe1, 0xf, 0xff, + 0xff, 0xc2, 0x0, 0x5f, 0x70, 0x4f, 0x50, 0xf, + 0xa4, 0x46, 0xee, 0x0, 0xa, 0xf0, 0xae, 0x0, + 0xf, 0x80, 0x0, 0x6f, 0x30, 0x3, 0xf5, 0xda, + 0x0, 0xf, 0x80, 0x0, 0x6f, 0x30, 0x0, 0xf8, + 0xf8, 0x0, 0xf, 0x81, 0x14, 0xed, 0x0, 0x0, + 0xda, 0xf8, 0x0, 0xf, 0xff, 0xff, 0xc2, 0x0, + 0x0, 0xda, 0xda, 0x0, 0xf, 0xa4, 0x8e, 0x50, + 0x0, 0x0, 0xe8, 0xae, 0x0, 0xf, 0x80, 0x8, + 0xf3, 0x0, 0x3, 0xf5, 0x4f, 0x50, 0xf, 0x80, + 0x0, 0xdd, 0x0, 0xa, 0xe0, 0xc, 0xe1, 0xf, + 0x80, 0x0, 0x4f, 0x80, 0x4f, 0x70, 0x2, 0xfc, + 0x12, 0x10, 0x0, 0x1, 0x13, 0xfc, 0x0, 0x0, + 0x4f, 0xe5, 0x0, 0x0, 0x0, 0x7f, 0xd1, 0x0, + 0x0, 0x2, 0xcf, 0xea, 0x88, 0xbf, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xad, 0xff, 0xd9, 0x30, + 0x0, 0x0, + + /* U+00B0 "°" */ + 0x0, 0x0, 0x0, 0x0, 0x2, 0xbf, 0xe8, 0x0, + 0xe, 0xb4, 0x6e, 0x80, 0x5f, 0x0, 0x6, 0xe0, + 0x5e, 0x0, 0x5, 0xf0, 0x1f, 0x91, 0x3d, 0xa0, + 0x4, 0xef, 0xfb, 0x10, 0x0, 0x2, 0x10, 0x0, + + /* U+00B1 "±" */ + 0x0, 0x0, 0x9, 0x90, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xf0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0xf, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xfb, + + /* U+00B2 "²" */ + 0x3, 0xbe, 0xfd, 0x70, 0x1f, 0xe7, 0x6d, 0xf5, + 0x27, 0x30, 0x5, 0xf7, 0x0, 0x0, 0x1c, 0xe1, + 0x0, 0x5, 0xed, 0x20, 0x0, 0xaf, 0x80, 0x0, + 0xc, 0xfa, 0x66, 0x63, 0x8f, 0xff, 0xff, 0xf9, + + /* U+00B3 "³" */ + 0x4, 0xcf, 0xfc, 0x50, 0x2f, 0xd6, 0x5e, 0xf1, + 0x1, 0x0, 0x2d, 0xe0, 0x0, 0x9, 0xfe, 0x40, + 0x0, 0x2, 0x4b, 0xf3, 0x36, 0x10, 0x5, 0xf8, + 0x4f, 0xd6, 0x7e, 0xf4, 0x5, 0xcf, 0xfc, 0x40, + + /* U+00B5 "µ" */ + 0x5f, 0xb0, 0x0, 0x0, 0x6f, 0xb5, 0xfb, 0x0, + 0x0, 0x6, 0xfb, 0x5f, 0xb0, 0x0, 0x0, 0x6f, + 0xb5, 0xfb, 0x0, 0x0, 0x6, 0xfb, 0x5f, 0xb0, + 0x0, 0x0, 0x6f, 0xb5, 0xfb, 0x0, 0x0, 0x6, + 0xfb, 0x5f, 0xb0, 0x0, 0x0, 0x6f, 0xb5, 0xfc, + 0x0, 0x0, 0x6, 0xfb, 0x5f, 0xe0, 0x0, 0x0, + 0x8f, 0xb5, 0xff, 0x30, 0x0, 0xd, 0xfb, 0x5f, + 0xfd, 0x30, 0x2b, 0xff, 0xb5, 0xfe, 0xff, 0xff, + 0xfc, 0xfb, 0x5f, 0xb4, 0xcf, 0xe8, 0x3f, 0xb5, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xb0, 0x0, + 0x0, 0x0, 0x5, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xb0, 0x0, 0x0, 0x0, 0x5, 0xfb, 0x0, + 0x0, 0x0, 0x0, + + /* U+00B6 "¶" */ + 0x0, 0x5, 0xbe, 0xff, 0xff, 0xff, 0xfe, 0x0, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x6, 0xff, + 0xff, 0xfa, 0x11, 0xcf, 0x40, 0xc, 0xff, 0xff, + 0xfa, 0x0, 0xcf, 0x30, 0xf, 0xff, 0xff, 0xfa, + 0x0, 0xcf, 0x30, 0xf, 0xff, 0xff, 0xfa, 0x0, + 0xcf, 0x30, 0xe, 0xff, 0xff, 0xfa, 0x0, 0xcf, + 0x30, 0x8, 0xff, 0xff, 0xfa, 0x0, 0xcf, 0x30, + 0x0, 0xdf, 0xff, 0xfa, 0x0, 0xcf, 0x30, 0x0, + 0x19, 0xef, 0xfa, 0x0, 0xcf, 0x30, 0x0, 0x0, + 0x5, 0xfa, 0x0, 0xcf, 0x30, 0x0, 0x0, 0x5, + 0xfa, 0x0, 0xcf, 0x30, 0x0, 0x0, 0x5, 0xfa, + 0x0, 0xcf, 0x30, 0x0, 0x0, 0x5, 0xfa, 0x0, + 0xcf, 0x30, 0x0, 0x0, 0x5, 0xfa, 0x0, 0xcf, + 0x30, 0x0, 0x0, 0x5, 0xfa, 0x0, 0xcf, 0x30, + 0x0, 0x0, 0x5, 0xfa, 0x0, 0xcf, 0x30, 0x0, + 0x0, 0x5, 0xfa, 0x0, 0xcf, 0x30, 0x0, 0x0, + 0x5, 0xfa, 0x0, 0xcf, 0x30, 0x0, 0x0, 0x5, + 0xfa, 0x0, 0xcf, 0x30, 0x0, 0x0, 0x5, 0xfa, + 0x0, 0xcf, 0x30, 0x0, 0x0, 0x5, 0xfa, 0x0, + 0xcf, 0x30, 0x0, 0x0, 0x5, 0xfa, 0x0, 0xcf, + 0x30, + + /* U+00B7 "·" */ + 0x67, 0x4d, 0xf9, 0xdf, 0x90, + + /* U+00BB "»" */ + 0x1d, 0xa0, 0x6, 0xe4, 0x0, 0x0, 0x8f, 0x60, + 0xe, 0xe1, 0x0, 0x0, 0xef, 0x20, 0x6f, 0xa0, + 0x0, 0x6, 0xfb, 0x0, 0xdf, 0x50, 0x0, 0xc, + 0xf6, 0x4, 0xfe, 0x10, 0x0, 0x5f, 0xf0, 0xd, + 0xf8, 0x0, 0xc, 0xf7, 0x3, 0xff, 0x20, 0x5, + 0xfc, 0x0, 0xcf, 0x60, 0x0, 0xdf, 0x20, 0x5f, + 0xb0, 0x0, 0x7f, 0x70, 0xd, 0xe1, 0x0, 0x1f, + 0xc0, 0x7, 0xf5, 0x0, 0x0, + + /* U+00BD "½" */ + 0x0, 0x3f, 0x90, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0x20, 0x0, 0x5f, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0x60, 0x0, 0xaf, 0xbf, 0x90, 0x0, 0x0, + 0x0, 0x2f, 0xb0, 0x0, 0x6, 0x32, 0xf9, 0x0, + 0x0, 0x0, 0xc, 0xe1, 0x0, 0x0, 0x0, 0x2f, + 0x90, 0x0, 0x0, 0x8, 0xf5, 0x0, 0x0, 0x0, + 0x2, 0xf9, 0x0, 0x0, 0x3, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0x90, 0x0, 0x0, 0xde, 0x10, + 0x0, 0x0, 0x0, 0x2, 0xf9, 0x0, 0x0, 0x9f, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x1e, 0x80, 0x0, + 0x4f, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xd0, 0x3, 0xcf, 0xfe, 0x70, 0x0, + 0x0, 0x0, 0xa, 0xf3, 0x1, 0xfe, 0x65, 0xdf, + 0x40, 0x0, 0x0, 0x5, 0xf8, 0x0, 0x3a, 0x50, + 0x5, 0xf8, 0x0, 0x0, 0x1, 0xed, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0x50, 0x0, 0x0, 0xaf, 0x20, + 0x0, 0x0, 0x0, 0x8f, 0xc0, 0x0, 0x0, 0x5f, + 0x70, 0x0, 0x0, 0x0, 0xbf, 0xc1, 0x0, 0x0, + 0x1f, 0xc0, 0x0, 0x0, 0x1, 0xdf, 0xa0, 0x0, + 0x0, 0xb, 0xf2, 0x0, 0x0, 0x0, 0xcf, 0x92, + 0x22, 0x10, 0x6, 0xf6, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xf9, 0x1, 0xca, 0x0, 0x0, 0x0, + 0x3, 0x55, 0x55, 0x55, 0x20, + + /* U+0384 "΄" */ + 0x0, 0x55, 0x40, 0x3f, 0xf4, 0xb, 0xf7, 0x2, + 0xfb, 0x0, + + /* U+0386 "Ά" */ + 0x0, 0x1f, 0xf9, 0x9, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xc0, 0xe, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0xee, 0x10, 0x5f, 0xbf, 0xf0, + 0x0, 0x0, 0x0, 0x1, 0x52, 0x0, 0xbf, 0x6c, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0x17, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xfc, 0x1, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xf7, 0x0, 0xcf, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xf2, 0x0, 0x6f, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xc0, 0x0, 0x1f, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0xef, 0x70, 0x0, 0xb, 0xfb, + 0x0, 0x0, 0x0, 0x4, 0xff, 0x10, 0x0, 0x6, + 0xff, 0x20, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0xf, 0xfe, 0xee, + 0xee, 0xee, 0xff, 0xe0, 0x0, 0x0, 0x5f, 0xf1, + 0x0, 0x0, 0x0, 0x4f, 0xf4, 0x0, 0x0, 0xbf, + 0xb0, 0x0, 0x0, 0x0, 0xe, 0xfb, 0x0, 0x1, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x8, 0xff, 0x10, + 0x7, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0x70, 0xd, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xd0, + + /* U+0388 "Έ" */ + 0x0, 0xbf, 0xd0, 0x4f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf2, 0x3, 0xff, 0x20, 0x4f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf2, 0xa, 0xf5, 0x0, 0x4f, + 0xf1, 0x11, 0x11, 0x11, 0x11, 0x10, 0x5, 0x40, + 0x0, 0x4f, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x4f, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xf1, 0x11, 0x11, 0x11, 0x11, 0x10, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf8, + + /* U+0389 "Ή" */ + 0x0, 0xbf, 0xd0, 0xcf, 0x80, 0x0, 0x0, 0x0, + 0x9, 0xfb, 0x2, 0xff, 0x20, 0xcf, 0x80, 0x0, + 0x0, 0x0, 0x9, 0xfb, 0xa, 0xf5, 0x0, 0xcf, + 0x80, 0x0, 0x0, 0x0, 0x9, 0xfb, 0x5, 0x40, + 0x0, 0xcf, 0x80, 0x0, 0x0, 0x0, 0x9, 0xfb, + 0x0, 0x0, 0x0, 0xcf, 0x80, 0x0, 0x0, 0x0, + 0x9, 0xfb, 0x0, 0x0, 0x0, 0xcf, 0x80, 0x0, + 0x0, 0x0, 0x9, 0xfb, 0x0, 0x0, 0x0, 0xcf, + 0x80, 0x0, 0x0, 0x0, 0x9, 0xfb, 0x0, 0x0, + 0x0, 0xcf, 0x81, 0x11, 0x11, 0x11, 0x19, 0xfb, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0xcf, + 0x80, 0x0, 0x0, 0x0, 0x9, 0xfb, 0x0, 0x0, + 0x0, 0xcf, 0x80, 0x0, 0x0, 0x0, 0x9, 0xfb, + 0x0, 0x0, 0x0, 0xcf, 0x80, 0x0, 0x0, 0x0, + 0x9, 0xfb, 0x0, 0x0, 0x0, 0xcf, 0x80, 0x0, + 0x0, 0x0, 0x9, 0xfb, 0x0, 0x0, 0x0, 0xcf, + 0x80, 0x0, 0x0, 0x0, 0x9, 0xfb, 0x0, 0x0, + 0x0, 0xcf, 0x80, 0x0, 0x0, 0x0, 0x9, 0xfb, + 0x0, 0x0, 0x0, 0xcf, 0x80, 0x0, 0x0, 0x0, + 0x9, 0xfb, 0x0, 0x0, 0x0, 0xcf, 0x80, 0x0, + 0x0, 0x0, 0x9, 0xfb, + + /* U+038A "Ί" */ + 0x0, 0xbf, 0xd0, 0xcf, 0x80, 0x2f, 0xf2, 0xc, + 0xf8, 0xa, 0xf5, 0x0, 0xcf, 0x80, 0x54, 0x0, + 0xc, 0xf8, 0x0, 0x0, 0x0, 0xcf, 0x80, 0x0, + 0x0, 0xc, 0xf8, 0x0, 0x0, 0x0, 0xcf, 0x80, + 0x0, 0x0, 0xc, 0xf8, 0x0, 0x0, 0x0, 0xcf, + 0x80, 0x0, 0x0, 0xc, 0xf8, 0x0, 0x0, 0x0, + 0xcf, 0x80, 0x0, 0x0, 0xc, 0xf8, 0x0, 0x0, + 0x0, 0xcf, 0x80, 0x0, 0x0, 0xc, 0xf8, 0x0, + 0x0, 0x0, 0xcf, 0x80, 0x0, 0x0, 0xc, 0xf8, + 0x0, 0x0, 0x0, 0xcf, 0x80, 0x0, 0x0, 0xc, + 0xf8, + + /* U+038C "Ό" */ + 0x0, 0xbf, 0xd0, 0x2, 0x8c, 0xef, 0xeb, 0x50, + 0x0, 0x0, 0x3, 0xff, 0x20, 0x8f, 0xff, 0xff, + 0xff, 0xfd, 0x20, 0x0, 0xa, 0xf5, 0xa, 0xff, + 0xb4, 0x10, 0x27, 0xef, 0xe3, 0x0, 0x5, 0x40, + 0x7f, 0xf6, 0x0, 0x0, 0x0, 0x1d, 0xfd, 0x0, + 0x0, 0x0, 0xff, 0x80, 0x0, 0x0, 0x0, 0x1, + 0xff, 0x70, 0x0, 0x6, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xe0, 0x0, 0xa, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf2, 0x0, 0xd, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xf5, + 0x0, 0xe, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xf6, 0x0, 0xe, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xf6, 0x0, 0xd, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xf5, 0x0, 0xa, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf2, + 0x0, 0x5, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xe0, 0x0, 0x0, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x1, 0xff, 0x70, 0x0, 0x0, 0x7f, 0xf5, + 0x0, 0x0, 0x0, 0x1c, 0xfd, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xa3, 0x0, 0x26, 0xef, 0xe3, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xfd, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x2, 0x8d, 0xff, + 0xeb, 0x50, 0x0, 0x0, + + /* U+038E "Ύ" */ + 0x0, 0xbf, 0xd0, 0x3f, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xfd, 0x0, 0x3f, 0xf2, 0x0, 0x9f, + 0xf2, 0x0, 0x0, 0x0, 0x6, 0xff, 0x30, 0xa, + 0xf5, 0x0, 0x0, 0xef, 0xc0, 0x0, 0x0, 0x1, + 0xef, 0x80, 0x0, 0x54, 0x0, 0x0, 0x4, 0xff, + 0x60, 0x0, 0x0, 0xaf, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0x10, 0x0, 0x4f, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xfa, + 0x0, 0xe, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xf4, 0x8, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xd2, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xef, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0x50, 0x0, 0x0, 0x0, + + /* U+038F "Ώ" */ + 0x0, 0xbf, 0xd0, 0x2, 0x9d, 0xff, 0xea, 0x40, + 0x0, 0x0, 0x3f, 0xf2, 0x7, 0xff, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0xa, 0xf5, 0x8, 0xff, 0xc4, + 0x10, 0x3a, 0xff, 0xb0, 0x0, 0x54, 0x3, 0xff, + 0xa0, 0x0, 0x0, 0x7, 0xff, 0x60, 0x0, 0x0, + 0xcf, 0xd0, 0x0, 0x0, 0x0, 0xa, 0xfe, 0x0, + 0x0, 0x1f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xf5, 0x0, 0x5, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0x90, 0x0, 0x7f, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xfb, 0x0, 0x8, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xb0, 0x0, 0x7f, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xfa, 0x0, + 0x5, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0x80, 0x0, 0xf, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xf3, 0x0, 0x0, 0xaf, 0x80, 0x0, 0x0, + 0x0, 0x4, 0xfd, 0x0, 0x0, 0x1, 0xff, 0x10, + 0x0, 0x0, 0x0, 0xcf, 0x40, 0x0, 0x0, 0x5, + 0xfc, 0x0, 0x0, 0x0, 0x9f, 0x80, 0x0, 0x0, + 0x1, 0x17, 0xfd, 0x30, 0x1, 0xbf, 0xa1, 0x10, + 0x0, 0xc, 0xff, 0xff, 0xff, 0x0, 0xbf, 0xff, + 0xff, 0xf0, 0x0, 0xcf, 0xff, 0xff, 0xf0, 0xc, + 0xff, 0xff, 0xff, + + /* U+0390 "ΐ" */ + 0x0, 0x0, 0x8f, 0x80, 0x9, 0xf7, 0xe, 0xd1, + 0xfe, 0x9f, 0x76, 0xf2, 0x1f, 0xe2, 0x42, 0x33, + 0x0, 0x44, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xb0, 0x0, 0x0, 0x6, 0xfb, 0x0, 0x0, + 0x0, 0x6f, 0xb0, 0x0, 0x0, 0x6, 0xfb, 0x0, + 0x0, 0x0, 0x6f, 0xb0, 0x0, 0x0, 0x6, 0xfb, + 0x0, 0x0, 0x0, 0x6f, 0xb0, 0x0, 0x0, 0x6, + 0xfb, 0x0, 0x0, 0x0, 0x6f, 0xb0, 0x0, 0x0, + 0x6, 0xfb, 0x0, 0x0, 0x0, 0x6f, 0xb0, 0x0, + 0x0, 0x6, 0xfb, 0x0, 0x0, 0x0, 0x6f, 0xb0, + 0x0, + + /* U+0391 "Α" */ + 0x0, 0x0, 0x0, 0x9, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xbf, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0x6c, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0x27, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xfd, 0x2, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xf7, 0x0, 0xcf, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xf2, 0x0, 0x7f, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xc0, 0x0, 0x1f, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0xef, 0x70, 0x0, 0xc, 0xfb, + 0x0, 0x0, 0x0, 0x4, 0xff, 0x20, 0x0, 0x6, + 0xff, 0x20, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0xf, 0xfe, 0xee, + 0xee, 0xee, 0xff, 0xe0, 0x0, 0x0, 0x5f, 0xf1, + 0x0, 0x0, 0x0, 0x4f, 0xf4, 0x0, 0x0, 0xbf, + 0xb0, 0x0, 0x0, 0x0, 0xe, 0xfb, 0x0, 0x1, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x8, 0xff, 0x10, + 0x7, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0x70, 0xd, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xd0, + + /* U+0392 "Β" */ + 0x3f, 0xff, 0xff, 0xff, 0xeb, 0x40, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x3f, 0xf1, + 0x11, 0x11, 0x39, 0xff, 0x50, 0x3f, 0xf0, 0x0, + 0x0, 0x0, 0xbf, 0xb0, 0x3f, 0xf0, 0x0, 0x0, + 0x0, 0x6f, 0xd0, 0x3f, 0xf0, 0x0, 0x0, 0x0, + 0x5f, 0xd0, 0x3f, 0xf0, 0x0, 0x0, 0x0, 0xaf, + 0x90, 0x3f, 0xf1, 0x11, 0x11, 0x39, 0xfe, 0x10, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xd2, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x20, 0x3f, 0xf0, + 0x0, 0x0, 0x15, 0xdf, 0xe0, 0x3f, 0xf0, 0x0, + 0x0, 0x0, 0x1e, 0xf7, 0x3f, 0xf0, 0x0, 0x0, + 0x0, 0xa, 0xfa, 0x3f, 0xf0, 0x0, 0x0, 0x0, + 0xb, 0xfb, 0x3f, 0xf0, 0x0, 0x0, 0x0, 0x1e, + 0xf8, 0x3f, 0xf1, 0x11, 0x11, 0x25, 0xdf, 0xf2, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x3f, + 0xff, 0xff, 0xff, 0xfc, 0x92, 0x0, + + /* U+0393 "Γ" */ + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x1f, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0x1f, 0xf4, 0x11, 0x11, + 0x11, 0x10, 0x1f, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf3, + 0x0, 0x0, 0x0, 0x0, + + /* U+0394 "Δ" */ + 0x0, 0x0, 0x0, 0x9, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xbf, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0x6c, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0x16, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xfc, 0x1, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xf6, 0x0, 0xbf, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xf1, 0x0, 0x5f, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xb0, 0x0, 0xf, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0xef, 0x50, 0x0, 0xa, 0xfb, + 0x0, 0x0, 0x0, 0x4, 0xff, 0x0, 0x0, 0x4, + 0xff, 0x20, 0x0, 0x0, 0xa, 0xfa, 0x0, 0x0, + 0x0, 0xef, 0x80, 0x0, 0x0, 0xf, 0xf5, 0x0, + 0x0, 0x0, 0x8f, 0xe0, 0x0, 0x0, 0x6f, 0xf0, + 0x0, 0x0, 0x0, 0x3f, 0xf4, 0x0, 0x0, 0xcf, + 0xa0, 0x0, 0x0, 0x0, 0xd, 0xfb, 0x0, 0x1, + 0xff, 0x51, 0x11, 0x11, 0x11, 0x18, 0xff, 0x10, + 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x70, 0xd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd0, + + /* U+0395 "Ε" */ + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x1f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x1f, 0xf3, + 0x11, 0x11, 0x11, 0x11, 0x10, 0x1f, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x1f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x1f, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xf3, 0x11, 0x11, 0x11, 0x11, 0x10, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x1f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, + + /* U+0396 "Ζ" */ + 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x11, 0x11, 0x11, 0x11, 0x6f, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0x71, 0x11, 0x11, 0x11, 0x11, 0x10, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, + + /* U+0397 "Η" */ + 0x1f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xef, 0x61, + 0xff, 0x30, 0x0, 0x0, 0x0, 0xe, 0xf6, 0x1f, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0xef, 0x61, 0xff, + 0x30, 0x0, 0x0, 0x0, 0xe, 0xf6, 0x1f, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0xef, 0x61, 0xff, 0x30, + 0x0, 0x0, 0x0, 0xe, 0xf6, 0x1f, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0xef, 0x61, 0xff, 0x41, 0x11, + 0x11, 0x11, 0x1e, 0xf6, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x61, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf6, 0x1f, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0xef, 0x61, 0xff, 0x30, 0x0, 0x0, 0x0, + 0xe, 0xf6, 0x1f, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0xef, 0x61, 0xff, 0x30, 0x0, 0x0, 0x0, 0xe, + 0xf6, 0x1f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xef, + 0x61, 0xff, 0x30, 0x0, 0x0, 0x0, 0xe, 0xf6, + 0x1f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xef, 0x61, + 0xff, 0x30, 0x0, 0x0, 0x0, 0xe, 0xf6, + + /* U+0398 "Θ" */ + 0x0, 0x0, 0x18, 0xce, 0xfe, 0xb6, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xfd, 0x30, + 0x0, 0x0, 0x8f, 0xfb, 0x41, 0x2, 0x6e, 0xff, + 0x40, 0x0, 0x5f, 0xf7, 0x0, 0x0, 0x0, 0xc, + 0xfe, 0x10, 0xe, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xf9, 0x5, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xf0, 0x9f, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0x4c, 0xf9, 0x0, 0x11, 0x11, + 0x11, 0x0, 0xe, 0xf7, 0xdf, 0x80, 0x1f, 0xff, + 0xff, 0xfb, 0x0, 0xdf, 0x8d, 0xf7, 0x1, 0xff, + 0xff, 0xff, 0xb0, 0xd, 0xf8, 0xbf, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0x79, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf4, 0x4f, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x0, 0xef, + 0xa0, 0x0, 0x0, 0x0, 0x1, 0xef, 0x90, 0x5, + 0xff, 0x70, 0x0, 0x0, 0x0, 0xbf, 0xe1, 0x0, + 0x9, 0xff, 0xb4, 0x0, 0x16, 0xef, 0xf4, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xd3, 0x0, + 0x0, 0x0, 0x1, 0x8c, 0xff, 0xeb, 0x60, 0x0, + 0x0, + + /* U+0399 "Ι" */ + 0xcf, 0x7c, 0xf7, 0xcf, 0x7c, 0xf7, 0xcf, 0x7c, + 0xf7, 0xcf, 0x7c, 0xf7, 0xcf, 0x7c, 0xf7, 0xcf, + 0x7c, 0xf7, 0xcf, 0x7c, 0xf7, 0xcf, 0x7c, 0xf7, + 0xcf, 0x7c, 0xf7, + + /* U+039A "Κ" */ + 0x3f, 0xf0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0x33, + 0xff, 0x0, 0x0, 0x0, 0xc, 0xff, 0x30, 0x3f, + 0xf0, 0x0, 0x0, 0xc, 0xff, 0x30, 0x3, 0xff, + 0x0, 0x0, 0xb, 0xff, 0x30, 0x0, 0x3f, 0xf0, + 0x0, 0xb, 0xff, 0x40, 0x0, 0x3, 0xff, 0x0, + 0xa, 0xff, 0x40, 0x0, 0x0, 0x3f, 0xf0, 0xa, + 0xff, 0x40, 0x0, 0x0, 0x3, 0xff, 0x9, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x3f, 0xf9, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x3, 0xff, 0xff, 0x4b, 0xfe, + 0x10, 0x0, 0x0, 0x3f, 0xff, 0x40, 0x1f, 0xfb, + 0x0, 0x0, 0x3, 0xff, 0x50, 0x0, 0x6f, 0xf6, + 0x0, 0x0, 0x3f, 0xf0, 0x0, 0x0, 0xbf, 0xf2, + 0x0, 0x3, 0xff, 0x0, 0x0, 0x1, 0xff, 0xc0, + 0x0, 0x3f, 0xf0, 0x0, 0x0, 0x6, 0xff, 0x80, + 0x3, 0xff, 0x0, 0x0, 0x0, 0xb, 0xff, 0x30, + 0x3f, 0xf0, 0x0, 0x0, 0x0, 0x1e, 0xfd, 0x3, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf9, + + /* U+039B "Λ" */ + 0x0, 0x0, 0x0, 0x5f, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xfd, 0xdf, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xf8, 0x8f, 0x70, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xf3, 0x3f, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xe0, 0xe, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0x80, 0x8, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0xef, 0x20, 0x3, 0xfe, 0x0, 0x0, + 0x0, 0x5, 0xfd, 0x0, 0x0, 0xdf, 0x50, 0x0, + 0x0, 0xb, 0xf7, 0x0, 0x0, 0x8f, 0xb0, 0x0, + 0x0, 0x1f, 0xf1, 0x0, 0x0, 0x3f, 0xf1, 0x0, + 0x0, 0x7f, 0xc0, 0x0, 0x0, 0xd, 0xf7, 0x0, + 0x0, 0xdf, 0x60, 0x0, 0x0, 0x8, 0xfc, 0x0, + 0x3, 0xff, 0x10, 0x0, 0x0, 0x2, 0xff, 0x20, + 0x9, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xdf, 0x80, + 0xe, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xe0, + 0x5f, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xf4, + 0xbf, 0xa0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfa, + + /* U+039C "Μ" */ + 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf3, 0x3f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf3, 0x3f, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf3, 0x3f, 0xfb, 0xf5, 0x0, 0x0, + 0x0, 0xf, 0xdf, 0xf3, 0x3f, 0xf6, 0xfa, 0x0, + 0x0, 0x0, 0x5f, 0x7f, 0xf3, 0x3f, 0xf1, 0xff, + 0x0, 0x0, 0x0, 0xaf, 0x2f, 0xf3, 0x3f, 0xf0, + 0xcf, 0x40, 0x0, 0x0, 0xfd, 0xf, 0xf3, 0x3f, + 0xf0, 0x6f, 0x90, 0x0, 0x5, 0xf7, 0xf, 0xf3, + 0x3f, 0xf0, 0x1f, 0xe0, 0x0, 0xa, 0xf2, 0xf, + 0xf3, 0x3f, 0xf0, 0xc, 0xf4, 0x0, 0xf, 0xd0, + 0xf, 0xf3, 0x3f, 0xf0, 0x7, 0xf9, 0x0, 0x4f, + 0x80, 0xf, 0xf3, 0x3f, 0xf0, 0x2, 0xfe, 0x0, + 0xaf, 0x20, 0xf, 0xf3, 0x3f, 0xf0, 0x0, 0xdf, + 0x30, 0xed, 0x0, 0xf, 0xf3, 0x3f, 0xf0, 0x0, + 0x7f, 0x84, 0xf8, 0x0, 0xf, 0xf3, 0x3f, 0xf0, + 0x0, 0x2f, 0xd9, 0xf2, 0x0, 0xf, 0xf3, 0x3f, + 0xf0, 0x0, 0xd, 0xff, 0xd0, 0x0, 0xf, 0xf3, + 0x3f, 0xf0, 0x0, 0x8, 0xff, 0x80, 0x0, 0xf, + 0xf3, 0x3f, 0xf0, 0x0, 0x3, 0xff, 0x20, 0x0, + 0xf, 0xf3, + + /* U+039D "Ν" */ + 0x1f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xcf, 0x71, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0xc, 0xf7, 0x1f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0xcf, 0x71, 0xff, + 0xff, 0x70, 0x0, 0x0, 0xc, 0xf7, 0x1f, 0xf9, + 0xff, 0x20, 0x0, 0x0, 0xcf, 0x71, 0xff, 0x1d, + 0xfb, 0x0, 0x0, 0xc, 0xf7, 0x1f, 0xf1, 0x3f, + 0xf6, 0x0, 0x0, 0xcf, 0x71, 0xff, 0x10, 0x9f, + 0xe1, 0x0, 0xc, 0xf7, 0x1f, 0xf1, 0x0, 0xef, + 0xa0, 0x0, 0xcf, 0x71, 0xff, 0x10, 0x5, 0xff, + 0x40, 0xc, 0xf7, 0x1f, 0xf1, 0x0, 0xa, 0xfe, + 0x0, 0xcf, 0x71, 0xff, 0x10, 0x0, 0x1f, 0xf9, + 0xc, 0xf7, 0x1f, 0xf1, 0x0, 0x0, 0x6f, 0xf3, + 0xcf, 0x71, 0xff, 0x10, 0x0, 0x0, 0xcf, 0xdc, + 0xf7, 0x1f, 0xf1, 0x0, 0x0, 0x2, 0xff, 0xff, + 0x71, 0xff, 0x10, 0x0, 0x0, 0x7, 0xff, 0xf7, + 0x1f, 0xf1, 0x0, 0x0, 0x0, 0xd, 0xff, 0x71, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x3f, 0xf7, + + /* U+039E "Ξ" */ + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x6f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x1, 0x11, + 0x11, 0x11, 0x11, 0x11, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x11, + 0x11, 0x11, 0x11, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x11, 0x11, 0x11, 0x11, 0x11, 0x10, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + + /* U+039F "Ο" */ + 0x0, 0x0, 0x18, 0xce, 0xfe, 0xb6, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xfd, 0x30, + 0x0, 0x0, 0x8f, 0xfb, 0x41, 0x2, 0x6e, 0xff, + 0x40, 0x0, 0x5f, 0xf7, 0x0, 0x0, 0x0, 0xc, + 0xfe, 0x10, 0xe, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xf9, 0x5, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xf0, 0x9f, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0x4c, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xf7, 0xdf, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0x8d, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xf8, 0xbf, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0x79, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf4, 0x4f, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x0, 0xef, + 0xa0, 0x0, 0x0, 0x0, 0x1, 0xef, 0x90, 0x5, + 0xff, 0x70, 0x0, 0x0, 0x0, 0xbf, 0xe1, 0x0, + 0x9, 0xff, 0xb4, 0x0, 0x16, 0xef, 0xf4, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xd3, 0x0, + 0x0, 0x0, 0x1, 0x8c, 0xff, 0xeb, 0x60, 0x0, + 0x0, + + /* U+03A0 "Π" */ + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x61, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x1f, + 0xf4, 0x11, 0x11, 0x11, 0x11, 0xef, 0x61, 0xff, + 0x30, 0x0, 0x0, 0x0, 0xe, 0xf6, 0x1f, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0xef, 0x61, 0xff, 0x30, + 0x0, 0x0, 0x0, 0xe, 0xf6, 0x1f, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0xef, 0x61, 0xff, 0x30, 0x0, + 0x0, 0x0, 0xe, 0xf6, 0x1f, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0xef, 0x61, 0xff, 0x30, 0x0, 0x0, + 0x0, 0xe, 0xf6, 0x1f, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0xef, 0x61, 0xff, 0x30, 0x0, 0x0, 0x0, + 0xe, 0xf6, 0x1f, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0xef, 0x61, 0xff, 0x30, 0x0, 0x0, 0x0, 0xe, + 0xf6, 0x1f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xef, + 0x61, 0xff, 0x30, 0x0, 0x0, 0x0, 0xe, 0xf6, + 0x1f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xef, 0x61, + 0xff, 0x30, 0x0, 0x0, 0x0, 0xe, 0xf6, + + /* U+03A1 "Ρ" */ + 0x2f, 0xff, 0xff, 0xff, 0xed, 0xa3, 0x0, 0x2f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x2f, 0xf2, + 0x11, 0x11, 0x13, 0xbf, 0xf3, 0x2f, 0xf2, 0x0, + 0x0, 0x0, 0xd, 0xfa, 0x2f, 0xf2, 0x0, 0x0, + 0x0, 0x8, 0xfd, 0x2f, 0xf2, 0x0, 0x0, 0x0, + 0x6, 0xff, 0x2f, 0xf2, 0x0, 0x0, 0x0, 0x8, + 0xfd, 0x2f, 0xf2, 0x0, 0x0, 0x0, 0x1e, 0xf9, + 0x2f, 0xf3, 0x11, 0x11, 0x25, 0xdf, 0xf2, 0x2f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x2f, 0xff, + 0xff, 0xff, 0xfd, 0x92, 0x0, 0x2f, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A3 "Σ" */ + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x64, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf6, 0x2f, 0xfa, 0x11, + 0x11, 0x11, 0x11, 0x0, 0x4f, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xfc, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x9, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x6, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x2, 0xff, 0x91, 0x11, 0x11, 0x11, 0x10, + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe4, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, + + /* U+03A4 "Τ" */ + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x27, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x1, + 0x11, 0x11, 0xdf, 0x71, 0x11, 0x11, 0x0, 0x0, + 0x0, 0xd, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xf7, 0x0, 0x0, 0x0, + + /* U+03A5 "Υ" */ + 0x9f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xf7, + 0x1e, 0xfc, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xd0, + 0x5, 0xff, 0x60, 0x0, 0x0, 0x6, 0xff, 0x30, + 0x0, 0xbf, 0xe1, 0x0, 0x0, 0x1e, 0xf8, 0x0, + 0x0, 0x1f, 0xfa, 0x0, 0x0, 0xaf, 0xd0, 0x0, + 0x0, 0x6, 0xff, 0x40, 0x4, 0xff, 0x30, 0x0, + 0x0, 0x0, 0xcf, 0xd0, 0xd, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xf6, 0x7f, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xfe, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf0, 0x0, 0x0, 0x0, + + /* U+03A6 "Φ" */ + 0x0, 0x0, 0x0, 0x6, 0xb8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x8c, 0xef, 0xff, + 0xfd, 0xa4, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb1, 0x0, 0x8, 0xff, 0x92, + 0x9, 0xfb, 0x2, 0x8f, 0xfc, 0x0, 0x3f, 0xf5, + 0x0, 0x9, 0xfb, 0x0, 0x4, 0xff, 0x70, 0xaf, + 0xb0, 0x0, 0x9, 0xfb, 0x0, 0x0, 0x9f, 0xd0, + 0xdf, 0x70, 0x0, 0x9, 0xfb, 0x0, 0x0, 0x4f, + 0xf1, 0xff, 0x60, 0x0, 0x9, 0xfb, 0x0, 0x0, + 0x3f, 0xf2, 0xef, 0x70, 0x0, 0x9, 0xfb, 0x0, + 0x0, 0x4f, 0xf0, 0xbf, 0xc0, 0x0, 0x9, 0xfb, + 0x0, 0x0, 0x9f, 0xd0, 0x4f, 0xf6, 0x0, 0x9, + 0xfb, 0x0, 0x3, 0xff, 0x60, 0x9, 0xff, 0xa3, + 0x9, 0xfb, 0x2, 0x8f, 0xfb, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x2, 0x9d, 0xff, 0xff, 0xfd, 0x93, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xfb, 0x0, + 0x0, 0x0, 0x0, + + /* U+03A7 "Χ" */ + 0xc, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xe1, + 0x2, 0xff, 0x90, 0x0, 0x0, 0x3, 0xff, 0x50, + 0x0, 0x6f, 0xf4, 0x0, 0x0, 0xd, 0xf9, 0x0, + 0x0, 0xb, 0xfe, 0x10, 0x0, 0xaf, 0xd0, 0x0, + 0x0, 0x1, 0xff, 0xa0, 0x5, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x6f, 0xf4, 0x1e, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xfd, 0xbf, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xfd, 0xef, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xf4, 0x5f, 0xf6, 0x0, 0x0, + 0x0, 0x1, 0xef, 0x90, 0xa, 0xff, 0x20, 0x0, + 0x0, 0xb, 0xfe, 0x0, 0x1, 0xef, 0xc0, 0x0, + 0x0, 0x6f, 0xf4, 0x0, 0x0, 0x5f, 0xf7, 0x0, + 0x2, 0xff, 0x80, 0x0, 0x0, 0xa, 0xff, 0x20, + 0xc, 0xfd, 0x0, 0x0, 0x0, 0x1, 0xef, 0xc0, + 0x8f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf8, + + /* U+03A8 "Ψ" */ + 0x8f, 0xc0, 0x0, 0x1, 0xff, 0x20, 0x0, 0xb, + 0xf9, 0x8f, 0xc0, 0x0, 0x1, 0xff, 0x20, 0x0, + 0xb, 0xf9, 0x8f, 0xc0, 0x0, 0x1, 0xff, 0x20, + 0x0, 0xb, 0xf9, 0x8f, 0xc0, 0x0, 0x1, 0xff, + 0x20, 0x0, 0xb, 0xf9, 0x8f, 0xc0, 0x0, 0x1, + 0xff, 0x20, 0x0, 0xb, 0xf9, 0x8f, 0xc0, 0x0, + 0x1, 0xff, 0x20, 0x0, 0xc, 0xf8, 0x7f, 0xd0, + 0x0, 0x1, 0xff, 0x20, 0x0, 0xd, 0xf7, 0x5f, + 0xf0, 0x0, 0x1, 0xff, 0x20, 0x0, 0xf, 0xf5, + 0x1f, 0xf5, 0x0, 0x1, 0xff, 0x20, 0x0, 0x5f, + 0xf2, 0xb, 0xfe, 0x10, 0x1, 0xff, 0x20, 0x1, + 0xef, 0xb0, 0x2, 0xff, 0xe7, 0x21, 0xff, 0x22, + 0x6e, 0xff, 0x30, 0x0, 0x3e, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe4, 0x0, 0x0, 0x0, 0x7b, 0xef, + 0xff, 0xfe, 0xb7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0x20, 0x0, + 0x0, 0x0, + + /* U+03A9 "Ω" */ + 0x0, 0x0, 0x39, 0xdf, 0xfd, 0xa3, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x9f, 0xfb, 0x40, 0x4, 0xbf, 0xf9, 0x0, + 0x5, 0xff, 0x80, 0x0, 0x0, 0x8, 0xff, 0x40, + 0xd, 0xfc, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xd0, + 0x3f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf3, + 0x7f, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xf7, + 0x9f, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xf9, + 0xaf, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xf9, + 0x9f, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xf8, + 0x6f, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xf6, + 0x2f, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xf, 0xf1, + 0xc, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xb0, + 0x3, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xdf, 0x20, + 0x0, 0x7f, 0xb0, 0x0, 0x0, 0xa, 0xf6, 0x0, + 0x1, 0x19, 0xfc, 0x20, 0x2, 0xcf, 0x81, 0x10, + 0xdf, 0xff, 0xff, 0xd0, 0xd, 0xff, 0xff, 0xfd, + 0xdf, 0xff, 0xff, 0xd0, 0xd, 0xff, 0xff, 0xfd, + + /* U+03AA "Ϊ" */ + 0xf, 0xf3, 0xa, 0xf9, 0xf, 0xf3, 0xa, 0xf9, + 0x7, 0x71, 0x4, 0x74, 0x0, 0xd, 0xf7, 0x0, + 0x0, 0xd, 0xf7, 0x0, 0x0, 0xd, 0xf7, 0x0, + 0x0, 0xd, 0xf7, 0x0, 0x0, 0xd, 0xf7, 0x0, + 0x0, 0xd, 0xf7, 0x0, 0x0, 0xd, 0xf7, 0x0, + 0x0, 0xd, 0xf7, 0x0, 0x0, 0xd, 0xf7, 0x0, + 0x0, 0xd, 0xf7, 0x0, 0x0, 0xd, 0xf7, 0x0, + 0x0, 0xd, 0xf7, 0x0, 0x0, 0xd, 0xf7, 0x0, + 0x0, 0xd, 0xf7, 0x0, 0x0, 0xd, 0xf7, 0x0, + 0x0, 0xd, 0xf7, 0x0, 0x0, 0xd, 0xf7, 0x0, + 0x0, 0xd, 0xf7, 0x0, + + /* U+03AB "Ϋ" */ + 0x0, 0x0, 0x5f, 0xe0, 0xf, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xe0, 0xf, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x27, 0x60, 0x7, 0x71, 0x0, 0x0, + 0x9f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xf7, + 0x1e, 0xfc, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xd0, + 0x5, 0xff, 0x60, 0x0, 0x0, 0x6, 0xff, 0x30, + 0x0, 0xbf, 0xe1, 0x0, 0x0, 0x1e, 0xf8, 0x0, + 0x0, 0x1f, 0xfa, 0x0, 0x0, 0xaf, 0xd0, 0x0, + 0x0, 0x6, 0xff, 0x40, 0x4, 0xff, 0x30, 0x0, + 0x0, 0x0, 0xcf, 0xd0, 0xd, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xf6, 0x7f, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xfe, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf0, 0x0, 0x0, 0x0, + + /* U+03AC "ά" */ + 0x0, 0x0, 0x0, 0x3f, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x25, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4b, 0xff, 0xc5, 0x5, 0xfd, 0x0, + 0x7f, 0xfe, 0xcf, 0xf7, 0x9f, 0x80, 0x3f, 0xf8, + 0x0, 0xa, 0xfe, 0xf4, 0xb, 0xfc, 0x0, 0x0, + 0xd, 0xff, 0x10, 0xff, 0x60, 0x0, 0x0, 0x8f, + 0xd0, 0x1f, 0xf3, 0x0, 0x0, 0x5, 0xfa, 0x2, + 0xff, 0x30, 0x0, 0x0, 0x4f, 0x80, 0x1f, 0xf4, + 0x0, 0x0, 0x5, 0xfa, 0x0, 0xff, 0x60, 0x0, + 0x0, 0x8f, 0xd0, 0xa, 0xfc, 0x0, 0x0, 0xe, + 0xff, 0x0, 0x3f, 0xf7, 0x0, 0x1b, 0xfe, 0xf4, + 0x0, 0x7f, 0xfe, 0xcf, 0xf7, 0x9f, 0x80, 0x0, + 0x4b, 0xff, 0xc5, 0x4, 0xfc, + + /* U+03AD "έ" */ + 0x0, 0x0, 0x8f, 0xe2, 0x0, 0x0, 0x1, 0xff, + 0x40, 0x0, 0x0, 0x7, 0xf8, 0x0, 0x0, 0x0, + 0x4, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x9e, 0xfe, 0xa3, 0x0, 0xc, 0xff, + 0xef, 0xff, 0x60, 0x5f, 0xd1, 0x0, 0x79, 0x0, + 0x7f, 0x90, 0x0, 0x0, 0x0, 0x4f, 0xe3, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xeb, 0x0, 0x0, 0x7, + 0xff, 0xfe, 0x0, 0x0, 0x6f, 0xf5, 0x10, 0x0, + 0x0, 0xcf, 0x80, 0x0, 0x0, 0x0, 0xcf, 0x60, + 0x0, 0x2, 0x0, 0x9f, 0xd1, 0x0, 0x6f, 0x90, + 0x1e, 0xff, 0xce, 0xff, 0x80, 0x2, 0xae, 0xfe, + 0xa3, 0x0, + + /* U+03AE "ή" */ + 0x0, 0x0, 0x6, 0xff, 0x30, 0x0, 0x0, 0x0, + 0xdf, 0x70, 0x0, 0x0, 0x0, 0x5f, 0xa0, 0x0, + 0x0, 0x0, 0x3, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xf8, 0x19, 0xef, 0xe9, + 0x10, 0x6f, 0x9d, 0xff, 0xff, 0xfd, 0x6, 0xff, + 0xd4, 0x0, 0x4f, 0xf6, 0x6f, 0xf3, 0x0, 0x0, + 0xaf, 0xa6, 0xfe, 0x0, 0x0, 0x7, 0xfb, 0x6f, + 0xc0, 0x0, 0x0, 0x5f, 0xb6, 0xfb, 0x0, 0x0, + 0x5, 0xfc, 0x6f, 0xb0, 0x0, 0x0, 0x5f, 0xc6, + 0xfb, 0x0, 0x0, 0x5, 0xfc, 0x6f, 0xb0, 0x0, + 0x0, 0x5f, 0xc6, 0xfb, 0x0, 0x0, 0x5, 0xfc, + 0x6f, 0xb0, 0x0, 0x0, 0x5f, 0xc6, 0xfb, 0x0, + 0x0, 0x5, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xc0, 0x0, 0x0, 0x0, 0x5, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xc0, 0x0, 0x0, 0x0, 0x5, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xc0, + + /* U+03AF "ί" */ + 0x6, 0xff, 0x30, 0xdf, 0x60, 0x5f, 0xa0, 0x3, + 0x50, 0x0, 0x0, 0x0, 0x6, 0xfb, 0x0, 0x6f, + 0xb0, 0x6, 0xfb, 0x0, 0x6f, 0xb0, 0x6, 0xfb, + 0x0, 0x6f, 0xb0, 0x6, 0xfb, 0x0, 0x6f, 0xb0, + 0x6, 0xfb, 0x0, 0x6f, 0xb0, 0x6, 0xfb, 0x0, + 0x6f, 0xb0, 0x6, 0xfb, 0x0, + + /* U+03B0 "ΰ" */ + 0x3, 0x41, 0x9, 0xf7, 0x44, 0x0, 0xaf, 0x52, + 0xfa, 0x3f, 0xd0, 0xa, 0xf5, 0xad, 0x3, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xfb, 0x0, 0x0, 0x8, + 0xf9, 0x6f, 0xb0, 0x0, 0x0, 0x8f, 0x96, 0xfb, + 0x0, 0x0, 0x8, 0xf9, 0x6f, 0xb0, 0x0, 0x0, + 0x8f, 0x96, 0xfb, 0x0, 0x0, 0x8, 0xf9, 0x6f, + 0xb0, 0x0, 0x0, 0x8f, 0x96, 0xfb, 0x0, 0x0, + 0x8, 0xf9, 0x6f, 0xb0, 0x0, 0x0, 0x8f, 0x85, + 0xfc, 0x0, 0x0, 0xa, 0xf7, 0x3f, 0xf1, 0x0, + 0x0, 0xdf, 0x40, 0xdf, 0xb1, 0x0, 0x9f, 0xe0, + 0x3, 0xef, 0xfc, 0xef, 0xf4, 0x0, 0x2, 0x9e, + 0xfe, 0xa3, 0x0, + + /* U+03B1 "α" */ + 0x0, 0x4, 0xbf, 0xfc, 0x50, 0x5f, 0xd0, 0x7, + 0xff, 0xec, 0xff, 0x79, 0xf8, 0x3, 0xff, 0x80, + 0x0, 0xaf, 0xef, 0x40, 0xbf, 0xc0, 0x0, 0x0, + 0xdf, 0xf1, 0xf, 0xf6, 0x0, 0x0, 0x8, 0xfd, + 0x1, 0xff, 0x30, 0x0, 0x0, 0x5f, 0xa0, 0x2f, + 0xf3, 0x0, 0x0, 0x4, 0xf8, 0x1, 0xff, 0x40, + 0x0, 0x0, 0x5f, 0xa0, 0xf, 0xf6, 0x0, 0x0, + 0x8, 0xfd, 0x0, 0xaf, 0xc0, 0x0, 0x0, 0xef, + 0xf0, 0x3, 0xff, 0x70, 0x1, 0xbf, 0xef, 0x40, + 0x7, 0xff, 0xec, 0xff, 0x79, 0xf8, 0x0, 0x4, + 0xbf, 0xfc, 0x50, 0x4f, 0xc0, + + /* U+03B2 "β" */ + 0x0, 0x7, 0xcf, 0xfc, 0x50, 0x0, 0x1, 0xdf, + 0xfd, 0xef, 0xf7, 0x0, 0xb, 0xfb, 0x10, 0x6, + 0xff, 0x20, 0x1f, 0xf0, 0x0, 0x0, 0x9f, 0x80, + 0x4f, 0xc0, 0x0, 0x0, 0x5f, 0xa0, 0x5f, 0xb0, + 0x0, 0x0, 0x6f, 0x80, 0x5f, 0xb0, 0x0, 0x0, + 0xcf, 0x40, 0x5f, 0xb0, 0x0, 0x3a, 0xf8, 0x0, + 0x5f, 0xb0, 0x6f, 0xfe, 0x60, 0x0, 0x5f, 0xb0, + 0x39, 0xbf, 0xfb, 0x10, 0x5f, 0xb0, 0x0, 0x1, + 0xaf, 0xd0, 0x5f, 0xb0, 0x0, 0x0, 0xe, 0xf6, + 0x5f, 0xc0, 0x0, 0x0, 0x9, 0xfa, 0x5f, 0xe0, + 0x0, 0x0, 0x8, 0xfa, 0x5f, 0xf4, 0x0, 0x0, + 0xc, 0xf7, 0x5f, 0xfe, 0x30, 0x0, 0x7f, 0xf1, + 0x5f, 0xcd, 0xfb, 0x9c, 0xff, 0x50, 0x5f, 0xb0, + 0x8d, 0xfe, 0xb3, 0x0, 0x5f, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xb0, 0x0, 0x0, + 0x0, 0x0, + + /* U+03B3 "γ" */ + 0x8f, 0xa0, 0x0, 0x0, 0xa, 0xf8, 0x2f, 0xf0, + 0x0, 0x0, 0xf, 0xf2, 0xd, 0xf5, 0x0, 0x0, + 0x5f, 0xc0, 0x7, 0xfb, 0x0, 0x0, 0xaf, 0x70, + 0x1, 0xff, 0x10, 0x0, 0xff, 0x10, 0x0, 0xcf, + 0x60, 0x5, 0xfb, 0x0, 0x0, 0x6f, 0xb0, 0xb, + 0xf6, 0x0, 0x0, 0x1f, 0xf1, 0x1f, 0xf0, 0x0, + 0x0, 0xb, 0xf6, 0x6f, 0xa0, 0x0, 0x0, 0x5, + 0xfb, 0xcf, 0x50, 0x0, 0x0, 0x0, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xf1, 0x0, 0x0, + + /* U+03B4 "δ" */ + 0x0, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0xd, + 0xff, 0xbb, 0xbb, 0xbb, 0x40, 0x0, 0x1c, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xfc, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xfe, 0x40, 0x0, + 0x0, 0x0, 0x4b, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x7f, 0xfd, 0xab, 0xff, 0x90, 0x0, 0x3f, 0xf7, + 0x0, 0x3, 0xef, 0x70, 0xb, 0xfb, 0x0, 0x0, + 0x5, 0xfe, 0x0, 0xff, 0x50, 0x0, 0x0, 0xe, + 0xf4, 0x1f, 0xf1, 0x0, 0x0, 0x0, 0xbf, 0x62, + 0xff, 0x0, 0x0, 0x0, 0xa, 0xf7, 0x1f, 0xf1, + 0x0, 0x0, 0x0, 0xbf, 0x60, 0xef, 0x50, 0x0, + 0x0, 0xe, 0xf4, 0x8, 0xfc, 0x0, 0x0, 0x5, + 0xfe, 0x0, 0x1f, 0xfa, 0x0, 0x5, 0xff, 0x70, + 0x0, 0x4f, 0xff, 0xce, 0xff, 0x90, 0x0, 0x0, + 0x2a, 0xef, 0xeb, 0x40, 0x0, + + /* U+03B5 "ε" */ + 0x1, 0x9e, 0xfe, 0xa3, 0x0, 0xc, 0xff, 0xef, + 0xff, 0x60, 0x5f, 0xd1, 0x0, 0x79, 0x0, 0x7f, + 0x90, 0x0, 0x0, 0x0, 0x4f, 0xe3, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xeb, 0x0, 0x0, 0x7, 0xff, + 0xfe, 0x0, 0x0, 0x6f, 0xf5, 0x10, 0x0, 0x0, + 0xcf, 0x80, 0x0, 0x0, 0x0, 0xcf, 0x60, 0x0, + 0x2, 0x0, 0x9f, 0xd1, 0x0, 0x6f, 0x90, 0x1e, + 0xff, 0xce, 0xff, 0x80, 0x2, 0xae, 0xfe, 0xa3, + 0x0, + + /* U+03B6 "ζ" */ + 0x0, 0x4f, 0xff, 0xff, 0xff, 0x60, 0x2, 0xbb, + 0xbb, 0xef, 0xf3, 0x0, 0x0, 0x0, 0x5f, 0xd2, + 0x0, 0x0, 0x0, 0x7f, 0xb0, 0x0, 0x0, 0x0, + 0x6f, 0xc0, 0x0, 0x0, 0x0, 0x3f, 0xe1, 0x0, + 0x0, 0x0, 0xd, 0xf4, 0x0, 0x0, 0x0, 0x8, + 0xfa, 0x0, 0x0, 0x0, 0x1, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x8f, 0xa0, 0x0, 0x0, 0x0, 0xd, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x2f, 0xf0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0x0, 0x0, 0x0, 0x0, 0xf, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xf8, 0x42, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0xb1, 0x0, 0x3, 0xbe, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0x10, 0x0, 0x0, 0x0, 0xe, 0xf1, 0x0, 0x0, + 0x0, 0x7, 0xfc, 0x0, 0x0, 0x0, 0xf, 0xff, + 0x30, 0x0, 0x0, 0x4, 0xeb, 0x20, 0x0, + + /* U+03B7 "η" */ + 0x6f, 0x81, 0x9e, 0xfe, 0x91, 0x6, 0xf9, 0xdf, + 0xff, 0xff, 0xd0, 0x6f, 0xfd, 0x40, 0x4, 0xff, + 0x66, 0xff, 0x30, 0x0, 0xa, 0xfa, 0x6f, 0xe0, + 0x0, 0x0, 0x7f, 0xb6, 0xfc, 0x0, 0x0, 0x5, + 0xfb, 0x6f, 0xb0, 0x0, 0x0, 0x5f, 0xc6, 0xfb, + 0x0, 0x0, 0x5, 0xfc, 0x6f, 0xb0, 0x0, 0x0, + 0x5f, 0xc6, 0xfb, 0x0, 0x0, 0x5, 0xfc, 0x6f, + 0xb0, 0x0, 0x0, 0x5f, 0xc6, 0xfb, 0x0, 0x0, + 0x5, 0xfc, 0x6f, 0xb0, 0x0, 0x0, 0x5f, 0xc0, + 0x0, 0x0, 0x0, 0x5, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xc0, 0x0, 0x0, 0x0, 0x5, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xc0, 0x0, 0x0, + 0x0, 0x5, 0xfc, + + /* U+03B8 "θ" */ + 0x0, 0x8, 0xdf, 0xea, 0x30, 0x0, 0x1, 0xdf, + 0xfd, 0xef, 0xf4, 0x0, 0xa, 0xfc, 0x10, 0x8, + 0xfe, 0x0, 0x1f, 0xf2, 0x0, 0x0, 0xbf, 0x70, + 0x6f, 0xb0, 0x0, 0x0, 0x5f, 0xc0, 0xaf, 0x70, + 0x0, 0x0, 0x2f, 0xf0, 0xcf, 0x50, 0x0, 0x0, + 0xf, 0xf2, 0xdf, 0x40, 0x0, 0x0, 0xe, 0xf3, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xf4, 0xef, 0xcb, + 0xbb, 0xbb, 0xbf, 0xf4, 0xdf, 0x40, 0x0, 0x0, + 0xe, 0xf3, 0xcf, 0x60, 0x0, 0x0, 0xf, 0xf2, + 0xaf, 0x80, 0x0, 0x0, 0x2f, 0xf0, 0x6f, 0xc0, + 0x0, 0x0, 0x6f, 0xc0, 0x1f, 0xf2, 0x0, 0x0, + 0xcf, 0x70, 0xa, 0xfc, 0x10, 0x8, 0xfe, 0x10, + 0x1, 0xdf, 0xfc, 0xef, 0xf4, 0x0, 0x0, 0x8, + 0xdf, 0xea, 0x30, 0x0, + + /* U+03B9 "ι" */ + 0x6f, 0xb6, 0xfb, 0x6f, 0xb6, 0xfb, 0x6f, 0xb6, + 0xfb, 0x6f, 0xb6, 0xfb, 0x6f, 0xb6, 0xfb, 0x6f, + 0xb6, 0xfb, 0x6f, 0xb0, + + /* U+03BA "κ" */ + 0x6f, 0xa0, 0x0, 0xb, 0xfd, 0x26, 0xfa, 0x0, + 0xb, 0xfd, 0x10, 0x6f, 0xa0, 0xb, 0xfd, 0x10, + 0x6, 0xfa, 0xb, 0xfc, 0x10, 0x0, 0x6f, 0xbb, + 0xfc, 0x10, 0x0, 0x6, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x6f, 0xff, 0xfc, 0x0, 0x0, 0x6, 0xfd, + 0x2e, 0xf9, 0x0, 0x0, 0x6f, 0xa0, 0x4f, 0xf6, + 0x0, 0x6, 0xfa, 0x0, 0x7f, 0xf3, 0x0, 0x6f, + 0xa0, 0x0, 0xaf, 0xe1, 0x6, 0xfa, 0x0, 0x0, + 0xdf, 0xc0, 0x6f, 0xa0, 0x0, 0x2, 0xff, 0x90, + + /* U+03BB "λ" */ + 0x0, 0xc, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xfe, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0x40, 0x0, 0x0, 0xa, + 0xf9, 0xaf, 0xa0, 0x0, 0x0, 0xf, 0xf4, 0x4f, + 0xf0, 0x0, 0x0, 0x5f, 0xe0, 0xe, 0xf6, 0x0, + 0x0, 0xbf, 0x80, 0x8, 0xfb, 0x0, 0x1, 0xff, + 0x20, 0x2, 0xff, 0x10, 0x7, 0xfc, 0x0, 0x0, + 0xdf, 0x70, 0xd, 0xf6, 0x0, 0x0, 0x7f, 0xc0, + 0x2f, 0xf1, 0x0, 0x0, 0x1f, 0xf2, 0x8f, 0xb0, + 0x0, 0x0, 0xb, 0xf8, + + /* U+03BC "μ" */ + 0x5f, 0xb0, 0x0, 0x0, 0x6f, 0xb5, 0xfb, 0x0, + 0x0, 0x6, 0xfb, 0x5f, 0xb0, 0x0, 0x0, 0x6f, + 0xb5, 0xfb, 0x0, 0x0, 0x6, 0xfb, 0x5f, 0xb0, + 0x0, 0x0, 0x6f, 0xb5, 0xfb, 0x0, 0x0, 0x6, + 0xfb, 0x5f, 0xb0, 0x0, 0x0, 0x6f, 0xb5, 0xfc, + 0x0, 0x0, 0x6, 0xfb, 0x5f, 0xe0, 0x0, 0x0, + 0x8f, 0xb5, 0xff, 0x30, 0x0, 0xd, 0xfb, 0x5f, + 0xfd, 0x30, 0x2b, 0xff, 0xb5, 0xfe, 0xff, 0xff, + 0xfc, 0xfb, 0x5f, 0xb4, 0xcf, 0xe8, 0x3f, 0xb5, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xb0, 0x0, + 0x0, 0x0, 0x5, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xb0, 0x0, 0x0, 0x0, 0x5, 0xfb, 0x0, + 0x0, 0x0, 0x0, + + /* U+03BD "ν" */ + 0x8f, 0xb0, 0x0, 0x0, 0xa, 0xf8, 0x2f, 0xf1, + 0x0, 0x0, 0xf, 0xf2, 0xc, 0xf6, 0x0, 0x0, + 0x5f, 0xd0, 0x6, 0xfb, 0x0, 0x0, 0xaf, 0x70, + 0x1, 0xff, 0x10, 0x0, 0xff, 0x10, 0x0, 0xaf, + 0x60, 0x6, 0xfb, 0x0, 0x0, 0x5f, 0xc0, 0xb, + 0xf5, 0x0, 0x0, 0xe, 0xf1, 0x1f, 0xf0, 0x0, + 0x0, 0x9, 0xf6, 0x6f, 0xa0, 0x0, 0x0, 0x3, + 0xfb, 0xbf, 0x40, 0x0, 0x0, 0x0, 0xdf, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xf3, 0x0, 0x0, + + /* U+03BE "ξ" */ + 0x0, 0x2a, 0xdf, 0xff, 0x0, 0x4, 0xff, 0xfd, + 0xcc, 0x0, 0xe, 0xf7, 0x0, 0x0, 0x0, 0x3f, + 0xc0, 0x0, 0x0, 0x0, 0x2f, 0xd0, 0x0, 0x0, + 0x0, 0xc, 0xf9, 0x30, 0x0, 0x0, 0x1, 0xcf, + 0xff, 0xfe, 0x0, 0x0, 0xa, 0xff, 0xeb, 0x0, + 0x1, 0xdf, 0xa2, 0x0, 0x0, 0xd, 0xf9, 0x0, + 0x0, 0x0, 0x6f, 0xd0, 0x0, 0x0, 0x0, 0xcf, + 0x60, 0x0, 0x0, 0x0, 0xef, 0x40, 0x0, 0x0, + 0x0, 0xdf, 0x50, 0x0, 0x0, 0x0, 0xaf, 0xb0, + 0x0, 0x0, 0x0, 0x3f, 0xfb, 0x51, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xea, 0x10, 0x0, 0x28, 0xcf, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x4f, 0xf3, 0x0, + 0x0, 0x0, 0xc, 0xf4, 0x0, 0x0, 0x1, 0x6f, + 0xf1, 0x0, 0x0, 0xf, 0xff, 0x60, 0x0, 0x0, + 0x4e, 0xb4, 0x0, + + /* U+03BF "ο" */ + 0x0, 0x2, 0x9d, 0xfe, 0xb5, 0x0, 0x0, 0x5, + 0xff, 0xfc, 0xef, 0xfa, 0x0, 0x3, 0xff, 0x90, + 0x0, 0x4f, 0xf7, 0x0, 0xaf, 0xb0, 0x0, 0x0, + 0x5f, 0xf0, 0xf, 0xf4, 0x0, 0x0, 0x0, 0xef, + 0x41, 0xff, 0x10, 0x0, 0x0, 0xb, 0xf6, 0x2f, + 0xf0, 0x0, 0x0, 0x0, 0xaf, 0x71, 0xff, 0x10, + 0x0, 0x0, 0xb, 0xf6, 0xe, 0xf4, 0x0, 0x0, + 0x0, 0xef, 0x40, 0xaf, 0xb0, 0x0, 0x0, 0x5f, + 0xf0, 0x3, 0xff, 0x90, 0x0, 0x4f, 0xf7, 0x0, + 0x5, 0xff, 0xfc, 0xef, 0xfa, 0x0, 0x0, 0x2, + 0x9e, 0xfe, 0xb5, 0x0, 0x0, + + /* U+03C0 "π" */ + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x5, 0xcc, 0xcf, 0xfc, 0xcc, 0xcc, 0xff, 0xcc, + 0xc0, 0x0, 0x3, 0xfe, 0x0, 0x0, 0xe, 0xf3, + 0x0, 0x0, 0x0, 0x3f, 0xe0, 0x0, 0x0, 0xef, + 0x30, 0x0, 0x0, 0x3, 0xfe, 0x0, 0x0, 0xe, + 0xf3, 0x0, 0x0, 0x0, 0x3f, 0xe0, 0x0, 0x0, + 0xef, 0x30, 0x0, 0x0, 0x3, 0xfe, 0x0, 0x0, + 0xe, 0xf3, 0x0, 0x0, 0x0, 0x3f, 0xe0, 0x0, + 0x0, 0xef, 0x30, 0x0, 0x0, 0x3, 0xfe, 0x0, + 0x0, 0xe, 0xf3, 0x0, 0x0, 0x0, 0x3f, 0xe0, + 0x0, 0x0, 0xef, 0x30, 0x0, 0x0, 0x3, 0xfe, + 0x0, 0x0, 0xe, 0xf3, 0x0, 0x0, 0x0, 0x3f, + 0xe0, 0x0, 0x0, 0xef, 0x30, 0x0, 0x0, 0x3, + 0xfe, 0x0, 0x0, 0xe, 0xf3, 0x0, 0x0, + + /* U+03C1 "ρ" */ + 0x0, 0x7, 0xcf, 0xfc, 0x70, 0x0, 0x0, 0xcf, + 0xfd, 0xdf, 0xfc, 0x10, 0x8, 0xfe, 0x30, 0x2, + 0xcf, 0xb0, 0xe, 0xf4, 0x0, 0x0, 0x1f, 0xf3, + 0x3f, 0xe0, 0x0, 0x0, 0x9, 0xf8, 0x5f, 0xb0, + 0x0, 0x0, 0x6, 0xfb, 0x7f, 0xa0, 0x0, 0x0, + 0x6, 0xfc, 0x7f, 0xb0, 0x0, 0x0, 0x6, 0xfb, + 0x7f, 0xe0, 0x0, 0x0, 0x9, 0xf9, 0x7f, 0xf3, + 0x0, 0x0, 0x1e, 0xf4, 0x7f, 0xfd, 0x20, 0x1, + 0xcf, 0xc0, 0x7f, 0xef, 0xfd, 0xcf, 0xfd, 0x10, + 0x7f, 0xa3, 0xbe, 0xfd, 0x81, 0x0, 0x7f, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xa0, + 0x0, 0x0, 0x0, 0x0, + + /* U+03C2 "ς" */ + 0x0, 0x1, 0x7c, 0xef, 0xec, 0x20, 0x4, 0xef, + 0xfd, 0xce, 0xf0, 0x4, 0xff, 0x70, 0x0, 0x1, + 0x1, 0xef, 0x40, 0x0, 0x0, 0x0, 0x7f, 0x90, + 0x0, 0x0, 0x0, 0xc, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0xef, 0x10, 0x0, 0x0, 0x0, 0xf, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0x70, 0x0, 0x0, + 0x0, 0x6, 0xff, 0x30, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xa4, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xa2, 0x0, 0x0, 0x2, 0x8c, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x1, 0xcf, 0xa0, 0x0, 0x0, 0x0, + 0x8, 0xfb, 0x0, 0x0, 0x1, 0x4, 0xef, 0x80, + 0x0, 0x3, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x6e, + 0xfd, 0x80, 0x0, + + /* U+03C3 "σ" */ + 0x0, 0x2, 0x9e, 0xff, 0xff, 0xff, 0xff, 0x40, + 0x5, 0xff, 0xfc, 0xef, 0xff, 0xcc, 0xc3, 0x3, + 0xff, 0x80, 0x0, 0x4f, 0xf7, 0x0, 0x0, 0xbf, + 0xa0, 0x0, 0x0, 0x6f, 0xf0, 0x0, 0xf, 0xf3, + 0x0, 0x0, 0x0, 0xff, 0x40, 0x2, 0xff, 0x0, + 0x0, 0x0, 0xd, 0xf6, 0x0, 0x3f, 0xf0, 0x0, + 0x0, 0x0, 0xbf, 0x60, 0x2, 0xff, 0x0, 0x0, + 0x0, 0xd, 0xf5, 0x0, 0xf, 0xf3, 0x0, 0x0, + 0x0, 0xff, 0x30, 0x0, 0xbf, 0xa0, 0x0, 0x0, + 0x7f, 0xe0, 0x0, 0x3, 0xff, 0x70, 0x0, 0x4f, + 0xf6, 0x0, 0x0, 0x6, 0xff, 0xec, 0xef, 0xf9, + 0x0, 0x0, 0x0, 0x2, 0xae, 0xfe, 0xb4, 0x0, + 0x0, 0x0, + + /* U+03C4 "τ" */ + 0x7f, 0xff, 0xff, 0xff, 0xf5, 0xcc, 0xcf, 0xfc, + 0xcb, 0x0, 0x2, 0xff, 0x0, 0x0, 0x0, 0x2f, + 0xf0, 0x0, 0x0, 0x2, 0xff, 0x0, 0x0, 0x0, + 0x2f, 0xf0, 0x0, 0x0, 0x2, 0xff, 0x0, 0x0, + 0x0, 0x2f, 0xf0, 0x0, 0x0, 0x2, 0xff, 0x0, + 0x0, 0x0, 0x2f, 0xf0, 0x0, 0x0, 0x2, 0xff, + 0x0, 0x0, 0x0, 0x2f, 0xf0, 0x0, 0x0, 0x2, + 0xff, 0x0, 0x0, + + /* U+03C5 "υ" */ + 0x6f, 0xb0, 0x0, 0x0, 0x8f, 0x96, 0xfb, 0x0, + 0x0, 0x8, 0xf9, 0x6f, 0xb0, 0x0, 0x0, 0x8f, + 0x96, 0xfb, 0x0, 0x0, 0x8, 0xf9, 0x6f, 0xb0, + 0x0, 0x0, 0x8f, 0x96, 0xfb, 0x0, 0x0, 0x8, + 0xf9, 0x6f, 0xb0, 0x0, 0x0, 0x8f, 0x96, 0xfb, + 0x0, 0x0, 0x8, 0xf8, 0x5f, 0xc0, 0x0, 0x0, + 0xaf, 0x73, 0xff, 0x10, 0x0, 0xd, 0xf4, 0xd, + 0xfb, 0x10, 0x9, 0xfe, 0x0, 0x3e, 0xff, 0xce, + 0xff, 0x40, 0x0, 0x29, 0xef, 0xea, 0x30, 0x0, + + /* U+03C6 "φ" */ + 0x0, 0x4, 0xcb, 0x4, 0xdf, 0xea, 0x20, 0x0, + 0x6, 0xff, 0x70, 0xff, 0xee, 0xfe, 0x20, 0x3, + 0xff, 0x60, 0x2f, 0xf1, 0x8, 0xfc, 0x0, 0xaf, + 0x90, 0x2, 0xfe, 0x0, 0xd, 0xf3, 0xf, 0xf3, + 0x0, 0x2f, 0xe0, 0x0, 0x9f, 0x81, 0xff, 0x10, + 0x2, 0xfe, 0x0, 0x8, 0xfa, 0x2f, 0xf1, 0x0, + 0x2f, 0xe0, 0x0, 0x8f, 0xa0, 0xff, 0x30, 0x2, + 0xfe, 0x0, 0xb, 0xf8, 0xc, 0xf9, 0x0, 0x2f, + 0xe0, 0x1, 0xff, 0x30, 0x6f, 0xf3, 0x2, 0xfe, + 0x0, 0xaf, 0xc0, 0x0, 0xbf, 0xf5, 0x3f, 0xe1, + 0xaf, 0xe2, 0x0, 0x1, 0xbf, 0xff, 0xff, 0xff, + 0xd3, 0x0, 0x0, 0x0, 0x6c, 0xff, 0xfc, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xfe, 0x0, 0x0, 0x0, + + /* U+03C7 "χ" */ + 0x3f, 0xf1, 0x0, 0x0, 0x6, 0xfd, 0x0, 0xbf, + 0x90, 0x0, 0x0, 0xef, 0x50, 0x3, 0xff, 0x10, + 0x0, 0x6f, 0xd0, 0x0, 0xb, 0xf8, 0x0, 0xe, + 0xf5, 0x0, 0x0, 0x3f, 0xf0, 0x6, 0xfd, 0x0, + 0x0, 0x0, 0xbf, 0x70, 0xdf, 0x40, 0x0, 0x0, + 0x3, 0xfe, 0x6f, 0xc0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xdf, 0x60, 0x0, 0x0, + 0x0, 0x5f, 0xc3, 0xfe, 0x0, 0x0, 0x0, 0xd, + 0xf4, 0xb, 0xf7, 0x0, 0x0, 0x6, 0xfc, 0x0, + 0x3f, 0xf1, 0x0, 0x0, 0xef, 0x40, 0x0, 0xcf, + 0x80, 0x0, 0x7f, 0xc0, 0x0, 0x4, 0xff, 0x10, + 0x1e, 0xf4, 0x0, 0x0, 0xc, 0xf9, 0x8, 0xfc, + 0x0, 0x0, 0x0, 0x4f, 0xf2, + + /* U+03C8 "ψ" */ + 0x9f, 0x80, 0x0, 0x8f, 0x90, 0x0, 0x6f, 0xa9, + 0xf8, 0x0, 0x8, 0xf9, 0x0, 0x6, 0xfa, 0x9f, + 0x80, 0x0, 0x8f, 0x90, 0x0, 0x6f, 0xa9, 0xf8, + 0x0, 0x8, 0xf9, 0x0, 0x6, 0xfa, 0x9f, 0x80, + 0x0, 0x8f, 0x90, 0x0, 0x6f, 0xa9, 0xf8, 0x0, + 0x8, 0xf9, 0x0, 0x6, 0xfa, 0x8f, 0x80, 0x0, + 0x8f, 0x90, 0x0, 0x6f, 0xa8, 0xf9, 0x0, 0x8, + 0xf9, 0x0, 0x7, 0xfa, 0x7f, 0xb0, 0x0, 0x8f, + 0x90, 0x0, 0x9f, 0x83, 0xff, 0x10, 0x8, 0xf9, + 0x0, 0xe, 0xf5, 0xc, 0xfd, 0x30, 0x8f, 0x90, + 0x2c, 0xfd, 0x0, 0x1d, 0xff, 0xee, 0xfe, 0xef, + 0xfe, 0x20, 0x0, 0x7, 0xce, 0xff, 0xff, 0xd8, + 0x10, 0x0, 0x0, 0x0, 0x8, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xf9, 0x0, 0x0, 0x0, + + /* U+03C9 "ω" */ + 0x5, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xe, 0xf2, + 0x0, 0xdf, 0x40, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0x90, 0x3f, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0x8, 0xfa, 0x0, 0x0, 0x8c, 0x50, 0x0, + 0xe, 0xf4, 0xcf, 0x60, 0x0, 0xa, 0xf6, 0x0, + 0x0, 0xaf, 0x8e, 0xf4, 0x0, 0x0, 0xaf, 0x60, + 0x0, 0x8, 0xfa, 0xff, 0x30, 0x0, 0xa, 0xf6, + 0x0, 0x0, 0x7f, 0xbe, 0xf4, 0x0, 0x0, 0xbf, + 0x70, 0x0, 0x8, 0xfa, 0xcf, 0x60, 0x0, 0xc, + 0xf8, 0x0, 0x0, 0xaf, 0x89, 0xfb, 0x0, 0x0, + 0xff, 0xb0, 0x0, 0xe, 0xf5, 0x2f, 0xf4, 0x0, + 0x9f, 0x9f, 0x50, 0x8, 0xfe, 0x0, 0x8f, 0xfc, + 0xdf, 0x90, 0xcf, 0xcd, 0xff, 0x40, 0x0, 0x6d, + 0xfd, 0x70, 0x1, 0x9e, 0xfc, 0x30, 0x0, + + /* U+03CA "ϊ" */ + 0xaf, 0x90, 0x4f, 0xfa, 0xf9, 0x4, 0xff, 0x47, + 0x40, 0x17, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xfb, 0x0, 0x0, 0x6f, 0xb0, + 0x0, 0x6, 0xfb, 0x0, 0x0, 0x6f, 0xb0, 0x0, + 0x6, 0xfb, 0x0, 0x0, 0x6f, 0xb0, 0x0, 0x6, + 0xfb, 0x0, 0x0, 0x6f, 0xb0, 0x0, 0x6, 0xfb, + 0x0, 0x0, 0x6f, 0xb0, 0x0, 0x6, 0xfb, 0x0, + 0x0, 0x6f, 0xb0, 0x0, 0x6, 0xfb, 0x0, + + /* U+03CB "ϋ" */ + 0x0, 0xbf, 0x70, 0x5f, 0xd0, 0x0, 0xb, 0xf7, + 0x5, 0xfd, 0x0, 0x0, 0x57, 0x30, 0x27, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xfb, 0x0, 0x0, 0x8, + 0xf9, 0x6f, 0xb0, 0x0, 0x0, 0x8f, 0x96, 0xfb, + 0x0, 0x0, 0x8, 0xf9, 0x6f, 0xb0, 0x0, 0x0, + 0x8f, 0x96, 0xfb, 0x0, 0x0, 0x8, 0xf9, 0x6f, + 0xb0, 0x0, 0x0, 0x8f, 0x96, 0xfb, 0x0, 0x0, + 0x8, 0xf9, 0x6f, 0xb0, 0x0, 0x0, 0x8f, 0x85, + 0xfc, 0x0, 0x0, 0xa, 0xf7, 0x3f, 0xf1, 0x0, + 0x0, 0xdf, 0x40, 0xdf, 0xb1, 0x0, 0x9f, 0xe0, + 0x3, 0xef, 0xfc, 0xef, 0xf4, 0x0, 0x2, 0x9e, + 0xfe, 0xa3, 0x0, + + /* U+03CC "ό" */ + 0x0, 0x0, 0x0, 0x6f, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x35, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x29, 0xdf, 0xeb, 0x50, 0x0, 0x0, + 0x5f, 0xff, 0xce, 0xff, 0xa0, 0x0, 0x3f, 0xf9, + 0x0, 0x4, 0xff, 0x70, 0xa, 0xfb, 0x0, 0x0, + 0x5, 0xff, 0x0, 0xff, 0x40, 0x0, 0x0, 0xe, + 0xf4, 0x1f, 0xf1, 0x0, 0x0, 0x0, 0xbf, 0x62, + 0xff, 0x0, 0x0, 0x0, 0xa, 0xf7, 0x1f, 0xf1, + 0x0, 0x0, 0x0, 0xbf, 0x60, 0xef, 0x40, 0x0, + 0x0, 0xe, 0xf4, 0xa, 0xfb, 0x0, 0x0, 0x5, + 0xff, 0x0, 0x3f, 0xf9, 0x0, 0x4, 0xff, 0x70, + 0x0, 0x5f, 0xff, 0xce, 0xff, 0xa0, 0x0, 0x0, + 0x29, 0xef, 0xeb, 0x50, 0x0, + + /* U+03CD "ύ" */ + 0x0, 0x0, 0x7, 0xff, 0x20, 0x0, 0x0, 0x0, + 0xef, 0x50, 0x0, 0x0, 0x0, 0x6f, 0x90, 0x0, + 0x0, 0x0, 0x4, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xfb, 0x0, 0x0, 0x8, + 0xf9, 0x6f, 0xb0, 0x0, 0x0, 0x8f, 0x96, 0xfb, + 0x0, 0x0, 0x8, 0xf9, 0x6f, 0xb0, 0x0, 0x0, + 0x8f, 0x96, 0xfb, 0x0, 0x0, 0x8, 0xf9, 0x6f, + 0xb0, 0x0, 0x0, 0x8f, 0x96, 0xfb, 0x0, 0x0, + 0x8, 0xf9, 0x6f, 0xb0, 0x0, 0x0, 0x8f, 0x85, + 0xfc, 0x0, 0x0, 0xa, 0xf7, 0x3f, 0xf1, 0x0, + 0x0, 0xdf, 0x40, 0xdf, 0xb1, 0x0, 0x9f, 0xe0, + 0x3, 0xef, 0xfc, 0xef, 0xf4, 0x0, 0x2, 0x9e, + 0xfe, 0xa3, 0x0, + + /* U+03CE "ώ" */ + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xd1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x55, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0x20, 0xd, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xf9, 0x3, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xf0, 0x8f, 0xa0, 0x0, 0x8, + 0xc5, 0x0, 0x0, 0xef, 0x4c, 0xf6, 0x0, 0x0, + 0xaf, 0x60, 0x0, 0xa, 0xf8, 0xef, 0x40, 0x0, + 0xa, 0xf6, 0x0, 0x0, 0x8f, 0xaf, 0xf3, 0x0, + 0x0, 0xaf, 0x60, 0x0, 0x7, 0xfb, 0xef, 0x40, + 0x0, 0xb, 0xf7, 0x0, 0x0, 0x8f, 0xac, 0xf6, + 0x0, 0x0, 0xcf, 0x80, 0x0, 0xa, 0xf8, 0x9f, + 0xb0, 0x0, 0xf, 0xfb, 0x0, 0x0, 0xef, 0x52, + 0xff, 0x40, 0x9, 0xf9, 0xf5, 0x0, 0x8f, 0xe0, + 0x8, 0xff, 0xcd, 0xf9, 0xc, 0xfc, 0xdf, 0xf4, + 0x0, 0x6, 0xdf, 0xd7, 0x0, 0x19, 0xef, 0xc3, + 0x0, + + /* U+03F4 "ϴ" */ + 0x0, 0x0, 0x2f, 0xd0, 0x0, 0x4f, 0xc0, 0xaf, + 0x3c, 0xf4, 0x4f, 0xc1, 0xf7, 0xc, 0xf4, 0x14, + 0x31, 0x40, 0x3, 0x41 +}; + + +/*--------------------- + * GLYPH DESCRIPTION + *--------------------*/ + +static const lv_font_fmt_txt_glyph_dsc_t glyph_dsc[] = { + {.bitmap_index = 0, .adv_w = 0, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0} /* id = 0 reserved */, + {.bitmap_index = 0, .adv_w = 107, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 0, .adv_w = 107, .box_w = 3, .box_h = 18, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 27, .adv_w = 136, .box_w = 7, .box_h = 7, .ofs_x = 1, .ofs_y = 11}, + {.bitmap_index = 52, .adv_w = 214, .box_w = 14, .box_h = 18, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 178, .adv_w = 214, .box_w = 13, .box_h = 22, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 321, .adv_w = 341, .box_w = 19, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 492, .adv_w = 256, .box_w = 15, .box_h = 19, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 635, .adv_w = 73, .box_w = 3, .box_h = 7, .ofs_x = 1, .ofs_y = 11}, + {.bitmap_index = 646, .adv_w = 128, .box_w = 7, .box_h = 23, .ofs_x = 1, .ofs_y = -5}, + {.bitmap_index = 727, .adv_w = 128, .box_w = 7, .box_h = 23, .ofs_x = 0, .ofs_y = -5}, + {.bitmap_index = 808, .adv_w = 149, .box_w = 9, .box_h = 8, .ofs_x = 0, .ofs_y = 10}, + {.bitmap_index = 844, .adv_w = 224, .box_w = 12, .box_h = 12, .ofs_x = 1, .ofs_y = 3}, + {.bitmap_index = 916, .adv_w = 107, .box_w = 4, .box_h = 7, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 930, .adv_w = 128, .box_w = 8, .box_h = 3, .ofs_x = 0, .ofs_y = 5}, + {.bitmap_index = 942, .adv_w = 107, .box_w = 3, .box_h = 3, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 947, .adv_w = 107, .box_w = 7, .box_h = 18, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1010, .adv_w = 214, .box_w = 12, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1118, .adv_w = 214, .box_w = 7, .box_h = 18, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 1181, .adv_w = 214, .box_w = 13, .box_h = 18, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1298, .adv_w = 214, .box_w = 12, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1406, .adv_w = 214, .box_w = 13, .box_h = 18, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1523, .adv_w = 214, .box_w = 12, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1631, .adv_w = 214, .box_w = 12, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1739, .adv_w = 214, .box_w = 12, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1847, .adv_w = 214, .box_w = 12, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1955, .adv_w = 214, .box_w = 12, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2063, .adv_w = 107, .box_w = 3, .box_h = 13, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 2083, .adv_w = 107, .box_w = 4, .box_h = 17, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 2117, .adv_w = 224, .box_w = 12, .box_h = 13, .ofs_x = 1, .ofs_y = 2}, + {.bitmap_index = 2195, .adv_w = 224, .box_w = 12, .box_h = 8, .ofs_x = 1, .ofs_y = 5}, + {.bitmap_index = 2243, .adv_w = 224, .box_w = 12, .box_h = 13, .ofs_x = 1, .ofs_y = 2}, + {.bitmap_index = 2321, .adv_w = 214, .box_w = 12, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2429, .adv_w = 390, .box_w = 23, .box_h = 23, .ofs_x = 1, .ofs_y = -5}, + {.bitmap_index = 2694, .adv_w = 256, .box_w = 18, .box_h = 18, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 2856, .adv_w = 256, .box_w = 14, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2982, .adv_w = 277, .box_w = 16, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3126, .adv_w = 277, .box_w = 16, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3270, .adv_w = 256, .box_w = 14, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3396, .adv_w = 235, .box_w = 13, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3513, .adv_w = 299, .box_w = 17, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3666, .adv_w = 277, .box_w = 15, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3801, .adv_w = 107, .box_w = 3, .box_h = 18, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 3828, .adv_w = 192, .box_w = 11, .box_h = 18, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3927, .adv_w = 256, .box_w = 15, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4062, .adv_w = 214, .box_w = 12, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4170, .adv_w = 320, .box_w = 18, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4332, .adv_w = 277, .box_w = 15, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4467, .adv_w = 299, .box_w = 17, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4620, .adv_w = 256, .box_w = 14, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4746, .adv_w = 299, .box_w = 17, .box_h = 20, .ofs_x = 1, .ofs_y = -2}, + {.bitmap_index = 4916, .adv_w = 277, .box_w = 17, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 5069, .adv_w = 256, .box_w = 14, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 5195, .adv_w = 235, .box_w = 15, .box_h = 18, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5330, .adv_w = 277, .box_w = 15, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 5465, .adv_w = 256, .box_w = 16, .box_h = 18, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5609, .adv_w = 362, .box_w = 23, .box_h = 18, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5816, .adv_w = 256, .box_w = 16, .box_h = 18, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5960, .adv_w = 256, .box_w = 16, .box_h = 18, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6104, .adv_w = 235, .box_w = 15, .box_h = 18, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6239, .adv_w = 107, .box_w = 6, .box_h = 23, .ofs_x = 1, .ofs_y = -5}, + {.bitmap_index = 6308, .adv_w = 107, .box_w = 7, .box_h = 18, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6371, .adv_w = 107, .box_w = 6, .box_h = 23, .ofs_x = 0, .ofs_y = -5}, + {.bitmap_index = 6440, .adv_w = 180, .box_w = 11, .box_h = 10, .ofs_x = 0, .ofs_y = 8}, + {.bitmap_index = 6495, .adv_w = 214, .box_w = 15, .box_h = 2, .ofs_x = -1, .ofs_y = -5}, + {.bitmap_index = 6510, .adv_w = 128, .box_w = 5, .box_h = 4, .ofs_x = 1, .ofs_y = 14}, + {.bitmap_index = 6520, .adv_w = 214, .box_w = 13, .box_h = 13, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6605, .adv_w = 214, .box_w = 12, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 6713, .adv_w = 192, .box_w = 12, .box_h = 13, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6791, .adv_w = 214, .box_w = 12, .box_h = 18, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6899, .adv_w = 214, .box_w = 13, .box_h = 13, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6984, .adv_w = 107, .box_w = 8, .box_h = 18, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7056, .adv_w = 214, .box_w = 12, .box_h = 18, .ofs_x = 0, .ofs_y = -5}, + {.bitmap_index = 7164, .adv_w = 214, .box_w = 11, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 7263, .adv_w = 85, .box_w = 3, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 7290, .adv_w = 85, .box_w = 6, .box_h = 23, .ofs_x = -2, .ofs_y = -5}, + {.bitmap_index = 7359, .adv_w = 192, .box_w = 11, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 7458, .adv_w = 85, .box_w = 3, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 7485, .adv_w = 320, .box_w = 18, .box_h = 13, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 7602, .adv_w = 214, .box_w = 11, .box_h = 13, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 7674, .adv_w = 214, .box_w = 13, .box_h = 13, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7759, .adv_w = 214, .box_w = 12, .box_h = 18, .ofs_x = 1, .ofs_y = -5}, + {.bitmap_index = 7867, .adv_w = 214, .box_w = 12, .box_h = 18, .ofs_x = 0, .ofs_y = -5}, + {.bitmap_index = 7975, .adv_w = 128, .box_w = 8, .box_h = 13, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 8027, .adv_w = 192, .box_w = 12, .box_h = 13, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 8105, .adv_w = 107, .box_w = 7, .box_h = 18, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 8168, .adv_w = 214, .box_w = 11, .box_h = 13, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 8240, .adv_w = 192, .box_w = 12, .box_h = 13, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 8318, .adv_w = 277, .box_w = 18, .box_h = 13, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 8435, .adv_w = 192, .box_w = 12, .box_h = 13, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 8513, .adv_w = 192, .box_w = 12, .box_h = 18, .ofs_x = 0, .ofs_y = -5}, + {.bitmap_index = 8621, .adv_w = 192, .box_w = 12, .box_h = 13, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 8699, .adv_w = 128, .box_w = 8, .box_h = 23, .ofs_x = 0, .ofs_y = -5}, + {.bitmap_index = 8791, .adv_w = 100, .box_w = 3, .box_h = 23, .ofs_x = 2, .ofs_y = -5}, + {.bitmap_index = 8826, .adv_w = 128, .box_w = 8, .box_h = 23, .ofs_x = 0, .ofs_y = -5}, + {.bitmap_index = 8918, .adv_w = 224, .box_w = 13, .box_h = 6, .ofs_x = 1, .ofs_y = 6}, + {.bitmap_index = 8957, .adv_w = 107, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 8957, .adv_w = 214, .box_w = 13, .box_h = 19, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 9081, .adv_w = 214, .box_w = 13, .box_h = 12, .ofs_x = 0, .ofs_y = 3}, + {.bitmap_index = 9159, .adv_w = 214, .box_w = 14, .box_h = 18, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 9285, .adv_w = 100, .box_w = 3, .box_h = 23, .ofs_x = 2, .ofs_y = -5}, + {.bitmap_index = 9320, .adv_w = 214, .box_w = 12, .box_h = 23, .ofs_x = 1, .ofs_y = -5}, + {.bitmap_index = 9458, .adv_w = 128, .box_w = 8, .box_h = 3, .ofs_x = 0, .ofs_y = 15}, + {.bitmap_index = 9470, .adv_w = 283, .box_w = 18, .box_h = 18, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 9632, .adv_w = 144, .box_w = 9, .box_h = 8, .ofs_x = 0, .ofs_y = 9}, + {.bitmap_index = 9668, .adv_w = 214, .box_w = 11, .box_h = 11, .ofs_x = 1, .ofs_y = 1}, + {.bitmap_index = 9729, .adv_w = 224, .box_w = 12, .box_h = 8, .ofs_x = 1, .ofs_y = 5}, + {.bitmap_index = 9777, .adv_w = 128, .box_w = 8, .box_h = 3, .ofs_x = 0, .ofs_y = 5}, + {.bitmap_index = 9789, .adv_w = 283, .box_w = 18, .box_h = 18, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 9951, .adv_w = 154, .box_w = 8, .box_h = 8, .ofs_x = 1, .ofs_y = 10}, + {.bitmap_index = 9983, .adv_w = 224, .box_w = 12, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 10073, .adv_w = 128, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 9}, + {.bitmap_index = 10105, .adv_w = 128, .box_w = 8, .box_h = 8, .ofs_x = 0, .ofs_y = 9}, + {.bitmap_index = 10137, .adv_w = 214, .box_w = 11, .box_h = 18, .ofs_x = 1, .ofs_y = -5}, + {.bitmap_index = 10236, .adv_w = 206, .box_w = 14, .box_h = 23, .ofs_x = -1, .ofs_y = -5}, + {.bitmap_index = 10397, .adv_w = 108, .box_w = 3, .box_h = 3, .ofs_x = 2, .ofs_y = 7}, + {.bitmap_index = 10402, .adv_w = 214, .box_w = 11, .box_h = 11, .ofs_x = 1, .ofs_y = 1}, + {.bitmap_index = 10463, .adv_w = 320, .box_w = 19, .box_h = 19, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 10644, .adv_w = 128, .box_w = 5, .box_h = 4, .ofs_x = 2, .ofs_y = 15}, + {.bitmap_index = 10654, .adv_w = 256, .box_w = 18, .box_h = 18, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 10816, .adv_w = 301, .box_w = 20, .box_h = 18, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 10996, .adv_w = 322, .box_w = 20, .box_h = 18, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 11176, .adv_w = 147, .box_w = 9, .box_h = 18, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 11257, .adv_w = 297, .box_w = 20, .box_h = 18, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 11437, .adv_w = 329, .box_w = 23, .box_h = 18, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 11644, .adv_w = 289, .box_w = 19, .box_h = 18, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 11815, .adv_w = 85, .box_w = 9, .box_h = 18, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 11896, .adv_w = 256, .box_w = 18, .box_h = 18, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 12058, .adv_w = 256, .box_w = 14, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 12184, .adv_w = 212, .box_w = 12, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 12292, .adv_w = 257, .box_w = 18, .box_h = 18, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 12454, .adv_w = 256, .box_w = 14, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 12580, .adv_w = 235, .box_w = 15, .box_h = 18, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 12715, .adv_w = 277, .box_w = 15, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 12850, .adv_w = 299, .box_w = 17, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 13003, .adv_w = 107, .box_w = 3, .box_h = 18, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 13030, .adv_w = 256, .box_w = 15, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 13165, .adv_w = 257, .box_w = 16, .box_h = 18, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 13309, .adv_w = 320, .box_w = 18, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 13471, .adv_w = 277, .box_w = 15, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 13606, .adv_w = 250, .box_w = 14, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 13732, .adv_w = 299, .box_w = 17, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 13885, .adv_w = 277, .box_w = 15, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 14020, .adv_w = 256, .box_w = 14, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 14146, .adv_w = 237, .box_w = 13, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 14263, .adv_w = 235, .box_w = 15, .box_h = 18, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 14398, .adv_w = 256, .box_w = 16, .box_h = 18, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 14542, .adv_w = 306, .box_w = 18, .box_h = 19, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 14713, .adv_w = 256, .box_w = 16, .box_h = 18, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 14857, .adv_w = 321, .box_w = 18, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 15019, .adv_w = 287, .box_w = 16, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 15163, .adv_w = 107, .box_w = 8, .box_h = 21, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 15247, .adv_w = 256, .box_w = 16, .box_h = 21, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 15415, .adv_w = 222, .box_w = 13, .box_h = 18, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 15532, .adv_w = 171, .box_w = 10, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 15622, .adv_w = 214, .box_w = 11, .box_h = 23, .ofs_x = 1, .ofs_y = -5}, + {.bitmap_index = 15749, .adv_w = 85, .box_w = 5, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 15794, .adv_w = 210, .box_w = 11, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 15893, .adv_w = 222, .box_w = 13, .box_h = 13, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 15978, .adv_w = 221, .box_w = 12, .box_h = 23, .ofs_x = 1, .ofs_y = -5}, + {.bitmap_index = 16116, .adv_w = 192, .box_w = 12, .box_h = 18, .ofs_x = 0, .ofs_y = -5}, + {.bitmap_index = 16224, .adv_w = 214, .box_w = 13, .box_h = 18, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 16341, .adv_w = 171, .box_w = 10, .box_h = 13, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 16406, .adv_w = 169, .box_w = 11, .box_h = 23, .ofs_x = 0, .ofs_y = -5}, + {.bitmap_index = 16533, .adv_w = 214, .box_w = 11, .box_h = 18, .ofs_x = 1, .ofs_y = -5}, + {.bitmap_index = 16632, .adv_w = 214, .box_w = 12, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 16740, .adv_w = 85, .box_w = 3, .box_h = 13, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 16760, .adv_w = 191, .box_w = 11, .box_h = 13, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 16832, .adv_w = 192, .box_w = 12, .box_h = 18, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 16940, .adv_w = 214, .box_w = 11, .box_h = 18, .ofs_x = 1, .ofs_y = -5}, + {.bitmap_index = 17039, .adv_w = 192, .box_w = 12, .box_h = 13, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 17117, .adv_w = 172, .box_w = 10, .box_h = 23, .ofs_x = 1, .ofs_y = -5}, + {.bitmap_index = 17232, .adv_w = 214, .box_w = 13, .box_h = 13, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 17317, .adv_w = 265, .box_w = 17, .box_h = 13, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 17428, .adv_w = 218, .box_w = 12, .box_h = 18, .ofs_x = 1, .ofs_y = -5}, + {.bitmap_index = 17536, .adv_w = 185, .box_w = 11, .box_h = 18, .ofs_x = 1, .ofs_y = -5}, + {.bitmap_index = 17635, .adv_w = 237, .box_w = 15, .box_h = 13, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 17733, .adv_w = 152, .box_w = 9, .box_h = 13, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 17792, .adv_w = 210, .box_w = 11, .box_h = 13, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 17864, .adv_w = 249, .box_w = 15, .box_h = 18, .ofs_x = 0, .ofs_y = -5}, + {.bitmap_index = 17999, .adv_w = 202, .box_w = 13, .box_h = 18, .ofs_x = 0, .ofs_y = -5}, + {.bitmap_index = 18116, .adv_w = 274, .box_w = 15, .box_h = 18, .ofs_x = 1, .ofs_y = -5}, + {.bitmap_index = 18251, .adv_w = 300, .box_w = 17, .box_h = 13, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 18362, .adv_w = 85, .box_w = 7, .box_h = 18, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 18425, .adv_w = 210, .box_w = 11, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 18524, .adv_w = 214, .box_w = 13, .box_h = 18, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 18641, .adv_w = 210, .box_w = 11, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 18740, .adv_w = 300, .box_w = 17, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 18893, .adv_w = 128, .box_w = 10, .box_h = 4, .ofs_x = -1, .ofs_y = 14} +}; + +/*--------------------- + * CHARACTER MAPPING + *--------------------*/ + +static const uint8_t glyph_id_ofs_list_1[] = { + 0, 0, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 0, + 13, 14, 15, 16, 0, 17, 18, 19, + 0, 0, 0, 20, 0, 21 +}; + +static const uint8_t glyph_id_ofs_list_2[] = { + 0, 0, 1, 0, 2, 3, 4, 0, + 5 +}; + +/*Collect the unicode lists and glyph_id offsets*/ +static const lv_font_fmt_txt_cmap_t cmaps[] = +{ + { + .range_start = 32, .range_length = 95, .glyph_id_start = 1, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 160, .range_length = 30, .glyph_id_start = 96, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_1, .list_length = 30, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 900, .range_length = 9, .glyph_id_start = 118, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_2, .list_length = 9, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 910, .range_length = 20, .glyph_id_start = 124, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 931, .range_length = 44, .glyph_id_start = 144, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 1012, .range_length = 1, .glyph_id_start = 188, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + } +}; + + + +/*-------------------- + * ALL CUSTOM DATA + *--------------------*/ + +#if LVGL_VERSION_MAJOR == 8 +/*Store all the custom data of the font*/ +static lv_font_fmt_txt_glyph_cache_t cache; +#endif + +#if LVGL_VERSION_MAJOR >= 8 +static const lv_font_fmt_txt_dsc_t font_dsc = { +#else +static lv_font_fmt_txt_dsc_t font_dsc = { +#endif + .glyph_bitmap = glyph_bitmap, + .glyph_dsc = glyph_dsc, + .cmaps = cmaps, + .kern_dsc = NULL, + .kern_scale = 0, + .cmap_num = 6, + .bpp = 4, + .kern_classes = 0, + .bitmap_format = 0, +#if LVGL_VERSION_MAJOR == 8 + .cache = &cache +#endif + +}; + +extern const lv_font_t lv_font_montserrat_24; + + +/*----------------- + * PUBLIC FONT + *----------------*/ + +/*Initialize a public general font descriptor*/ +#if LVGL_VERSION_MAJOR >= 8 +const lv_font_t lv_font_arial_24 = { +#else +lv_font_t lv_font_arial_24 = { +#endif + .get_glyph_dsc = lv_font_get_glyph_dsc_fmt_txt, /*Function pointer to get glyph's data*/ + .get_glyph_bitmap = lv_font_get_bitmap_fmt_txt, /*Function pointer to get glyph's bitmap*/ + .line_height = 26, /*The maximum line height required by the font*/ + .base_line = 5, /*Baseline measured from the bottom of the line*/ +#if !(LVGL_VERSION_MAJOR == 6 && LVGL_VERSION_MINOR == 0) + .subpx = LV_FONT_SUBPX_NONE, +#endif +#if LV_VERSION_CHECK(7, 4, 0) || LVGL_VERSION_MAJOR >= 8 + .underline_position = -3, + .underline_thickness = 2, +#endif + //.static_bitmap = 0, + .dsc = &font_dsc, /*The custom font data. Will be accessed by `get_glyph_bitmap/dsc` */ +#if LV_VERSION_CHECK(8, 2, 0) || LVGL_VERSION_MAJOR >= 9 + .fallback = &lv_font_montserrat_24, +#endif + .user_data = NULL, +}; + + + +#endif /*#if LV_FONT_ARIAL_24*/ diff --git a/src/fonts/lv_font_arial_26.c b/src/fonts/lv_font_arial_26.c new file mode 100644 index 0000000000..8458c8b946 --- /dev/null +++ b/src/fonts/lv_font_arial_26.c @@ -0,0 +1,3501 @@ +/******************************************************************************* + * Size: 26 px + * Bpp: 4 + * Opts: --bpp 4 --size 26 --no-compress --stride 1 --align 1 --font Arial Greek Regular.ttf --range 32-127,160-255,880-1023 --format lvgl -o lv_font_arial_26.c + ******************************************************************************/ + +#ifdef __has_include + #if __has_include("lvgl.h") + #ifndef LV_LVGL_H_INCLUDE_SIMPLE + #define LV_LVGL_H_INCLUDE_SIMPLE + #endif + #endif +#endif + +#ifdef LV_LVGL_H_INCLUDE_SIMPLE + #include "lvgl.h" +#else + #include "lvgl/lvgl.h" +#endif + + + +#ifndef LV_FONT_ARIAL_26 +#define LV_FONT_ARIAL_26 1 +#endif + +#if LV_FONT_ARIAL_26 + +/*----------------- + * BITMAPS + *----------------*/ + +/*Store the image of the glyphs*/ +static LV_ATTRIBUTE_LARGE_CONST const uint8_t glyph_bitmap[] = { + /* U+0020 " " */ + + /* U+0021 "!" */ + 0xcf, 0xf0, 0xcf, 0xf0, 0xcf, 0xf0, 0xcf, 0xf0, + 0xcf, 0xf0, 0xbf, 0xf0, 0xaf, 0xe0, 0x9f, 0xd0, + 0x8f, 0xb0, 0x6f, 0xa0, 0x5f, 0x90, 0x4f, 0x80, + 0x3f, 0x70, 0x2f, 0x60, 0x3, 0x10, 0x0, 0x0, + 0x7a, 0x90, 0xbf, 0xe0, 0xbf, 0xe0, + + /* U+0022 "\"" */ + 0xcf, 0xd0, 0x9f, 0xf0, 0xcf, 0xd0, 0x9f, 0xf0, + 0xcf, 0xd0, 0x9f, 0xf0, 0xbf, 0xb0, 0x8f, 0xf0, + 0x8f, 0x90, 0x5f, 0xc0, 0x5f, 0x60, 0x2f, 0x90, + 0x2b, 0x30, 0xa, 0x50, + + /* U+0023 "#" */ + 0x0, 0x0, 0xd, 0xf1, 0x0, 0xe, 0xf0, 0x0, + 0x0, 0x1, 0xfd, 0x0, 0x2, 0xfc, 0x0, 0x0, + 0x0, 0x4f, 0x90, 0x0, 0x6f, 0x80, 0x0, 0x0, + 0x8, 0xf6, 0x0, 0x9, 0xf5, 0x0, 0x0, 0x0, + 0xbf, 0x20, 0x0, 0xdf, 0x10, 0xb, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf3, 0xae, 0xef, 0xff, + 0xee, 0xef, 0xff, 0xee, 0x20, 0x0, 0x5f, 0x90, + 0x0, 0x6f, 0x80, 0x0, 0x0, 0x8, 0xf6, 0x0, + 0x9, 0xf5, 0x0, 0x0, 0x0, 0xbf, 0x30, 0x0, + 0xcf, 0x20, 0x0, 0x0, 0xe, 0xf0, 0x0, 0xf, + 0xe0, 0x0, 0x0, 0x1, 0xfd, 0x0, 0x2, 0xfc, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x3a, 0xef, 0xff, 0xee, 0xef, 0xff, 0xee, + 0xe2, 0x0, 0xaf, 0x30, 0x0, 0xcf, 0x20, 0x0, + 0x0, 0xe, 0xf0, 0x0, 0xf, 0xe0, 0x0, 0x0, + 0x1, 0xfc, 0x0, 0x3, 0xfb, 0x0, 0x0, 0x0, + 0x5f, 0x90, 0x0, 0x6f, 0x70, 0x0, 0x0, 0x8, + 0xf5, 0x0, 0xa, 0xf4, 0x0, 0x0, 0x0, + + /* U+0024 "$" */ + 0x0, 0x0, 0x0, 0x7e, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6b, 0xef, 0xb8, 0x10, 0x0, 0x0, 0x2d, + 0xff, 0xff, 0xff, 0xe4, 0x0, 0x0, 0xdf, 0xe6, + 0x8e, 0x4d, 0xfe, 0x10, 0x4, 0xff, 0x30, 0x7e, + 0x1, 0xff, 0x70, 0x8, 0xfc, 0x0, 0x7e, 0x0, + 0xbf, 0x90, 0x9, 0xfb, 0x0, 0x7e, 0x0, 0x0, + 0x0, 0x8, 0xfe, 0x0, 0x7e, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xb0, 0x7e, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xfe, 0xce, 0x10, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xfc, 0x40, 0x0, 0x0, 0x0, 0x16, + 0xcf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x7e, + 0x4b, 0xff, 0x80, 0x0, 0x0, 0x0, 0x7e, 0x0, + 0xaf, 0xf0, 0x0, 0x0, 0x0, 0x7e, 0x0, 0x3f, + 0xf3, 0xa, 0xe6, 0x0, 0x7e, 0x0, 0x1f, 0xf4, + 0xd, 0xfa, 0x0, 0x7e, 0x0, 0x3f, 0xf2, 0x9, + 0xff, 0x20, 0x7e, 0x0, 0xaf, 0xe0, 0x2, 0xff, + 0xd3, 0x7e, 0x19, 0xff, 0x60, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x2, 0x9e, 0xff, + 0xfc, 0x50, 0x0, 0x0, 0x0, 0x0, 0x7e, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7e, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x37, 0x0, 0x0, 0x0, + + /* U+0025 "%" */ + 0x0, 0x7e, 0xfd, 0x70, 0x0, 0x0, 0x0, 0x8f, + 0x40, 0x0, 0x0, 0x9f, 0xea, 0xdf, 0x90, 0x0, + 0x0, 0x1f, 0xc0, 0x0, 0x0, 0x1f, 0xf1, 0x0, + 0xef, 0x20, 0x0, 0x9, 0xf3, 0x0, 0x0, 0x5, + 0xfa, 0x0, 0x9, 0xf6, 0x0, 0x2, 0xfb, 0x0, + 0x0, 0x0, 0x6f, 0x90, 0x0, 0x7f, 0x70, 0x0, + 0xaf, 0x20, 0x0, 0x0, 0x5, 0xfa, 0x0, 0x9, + 0xf6, 0x0, 0x3f, 0xa0, 0x0, 0x0, 0x0, 0x1f, + 0xe1, 0x0, 0xef, 0x20, 0xc, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xea, 0xdf, 0x90, 0x4, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7d, 0xfd, 0x70, + 0x0, 0xdf, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0x80, 0x6, 0xdf, 0xd7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xe0, 0x6, + 0xfe, 0xad, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xf7, 0x0, 0xef, 0x20, 0xe, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0xee, 0x0, 0x4f, 0xc0, 0x0, 0x9f, + 0x60, 0x0, 0x0, 0x0, 0x8f, 0x50, 0x6, 0xfa, + 0x0, 0x7, 0xf8, 0x0, 0x0, 0x0, 0x1f, 0xd0, + 0x0, 0x5f, 0xa0, 0x0, 0x7f, 0x80, 0x0, 0x0, + 0x9, 0xf4, 0x0, 0x3, 0xfb, 0x0, 0x9, 0xf6, + 0x0, 0x0, 0x2, 0xfc, 0x0, 0x0, 0xe, 0xf2, + 0x1, 0xef, 0x10, 0x0, 0x0, 0xaf, 0x30, 0x0, + 0x0, 0x6f, 0xea, 0xef, 0x80, 0x0, 0x0, 0x3f, + 0xb0, 0x0, 0x0, 0x0, 0x6d, 0xfd, 0x60, 0x0, + + /* U+0026 "&" */ + 0x0, 0x0, 0x4b, 0xff, 0xc5, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x2f, 0xf8, 0x0, 0xaf, 0xf1, 0x0, 0x0, + 0x0, 0x7f, 0xe0, 0x0, 0xf, 0xf5, 0x0, 0x0, + 0x0, 0x7f, 0xe0, 0x0, 0xf, 0xf4, 0x0, 0x0, + 0x0, 0x3f, 0xf6, 0x0, 0x6f, 0xe1, 0x0, 0x0, + 0x0, 0xa, 0xff, 0x36, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xe5, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xdf, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xfd, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0x70, 0x8f, 0xf9, 0x0, 0xda, 0x30, + 0x5f, 0xf6, 0x0, 0xb, 0xff, 0x55, 0xff, 0x20, + 0xbf, 0xc0, 0x0, 0x0, 0xdf, 0xfd, 0xfd, 0x0, + 0xdf, 0xa0, 0x0, 0x0, 0x2e, 0xff, 0xf5, 0x0, + 0xcf, 0xd0, 0x0, 0x0, 0x5, 0xff, 0xf1, 0x0, + 0x7f, 0xf5, 0x0, 0x0, 0x1c, 0xff, 0xfb, 0x0, + 0xe, 0xff, 0x71, 0x26, 0xef, 0xfb, 0xff, 0xb1, + 0x3, 0xef, 0xff, 0xff, 0xfe, 0x40, 0xaf, 0xf7, + 0x0, 0x18, 0xdf, 0xfd, 0x81, 0x0, 0x8, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0027 "'" */ + 0xdf, 0xcd, 0xfc, 0xdf, 0xcc, 0xfb, 0x9f, 0x86, + 0xf6, 0x3b, 0x20, + + /* U+0028 "(" */ + 0x0, 0x0, 0x4f, 0x70, 0x0, 0x1e, 0xd0, 0x0, + 0x9, 0xf5, 0x0, 0x2, 0xfd, 0x0, 0x0, 0xaf, + 0x70, 0x0, 0x1f, 0xf1, 0x0, 0x7, 0xfb, 0x0, + 0x0, 0xcf, 0x80, 0x0, 0xf, 0xf4, 0x0, 0x3, + 0xff, 0x10, 0x0, 0x5f, 0xf0, 0x0, 0x6, 0xff, + 0x0, 0x0, 0x6f, 0xf0, 0x0, 0x5, 0xff, 0x0, + 0x0, 0x3f, 0xf1, 0x0, 0x0, 0xff, 0x40, 0x0, + 0xc, 0xf8, 0x0, 0x0, 0x7f, 0xc0, 0x0, 0x2, + 0xff, 0x10, 0x0, 0xb, 0xf7, 0x0, 0x0, 0x3f, + 0xd0, 0x0, 0x0, 0x9f, 0x50, 0x0, 0x1, 0xed, + 0x0, 0x0, 0x4, 0xf7, + + /* U+0029 ")" */ + 0xc, 0xd0, 0x0, 0x0, 0x3, 0xfa, 0x0, 0x0, + 0x0, 0xaf, 0x40, 0x0, 0x0, 0x3f, 0xd0, 0x0, + 0x0, 0xc, 0xf5, 0x0, 0x0, 0x6, 0xfc, 0x0, + 0x0, 0x1, 0xff, 0x20, 0x0, 0x0, 0xdf, 0x70, + 0x0, 0x0, 0x9f, 0xb0, 0x0, 0x0, 0x7f, 0xd0, + 0x0, 0x0, 0x6f, 0xf0, 0x0, 0x0, 0x4f, 0xf0, + 0x0, 0x0, 0x4f, 0xf0, 0x0, 0x0, 0x6f, 0xf0, + 0x0, 0x0, 0x7f, 0xd0, 0x0, 0x0, 0xaf, 0xb0, + 0x0, 0x0, 0xdf, 0x70, 0x0, 0x1, 0xff, 0x20, + 0x0, 0x6, 0xfb, 0x0, 0x0, 0xd, 0xf4, 0x0, + 0x0, 0x3f, 0xc0, 0x0, 0x0, 0xaf, 0x40, 0x0, + 0x3, 0xfa, 0x0, 0x0, 0xc, 0xe1, 0x0, 0x0, + + /* U+002A "*" */ + 0x0, 0x0, 0xde, 0x0, 0x0, 0x0, 0x0, 0xcd, + 0x0, 0x0, 0xa, 0xa3, 0xbc, 0x29, 0xc0, 0xe, + 0xff, 0xff, 0xff, 0xf1, 0x0, 0x28, 0xff, 0x94, + 0x0, 0x0, 0x1d, 0xdd, 0xe2, 0x0, 0x0, 0xbf, + 0x54, 0xfd, 0x0, 0x0, 0x6b, 0x0, 0x98, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+002B "+" */ + 0x0, 0x0, 0x3, 0x75, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xfa, 0x0, 0x0, + 0x1, 0x22, 0x22, 0x9f, 0xb2, 0x22, 0x22, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xb8, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x7, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xfa, 0x0, 0x0, 0x0, + + /* U+002C "," */ + 0x7a, 0x8b, 0xfd, 0xbf, 0xd0, 0x7c, 0xb, 0xa7, + 0xf3, 0x54, 0x0, + + /* U+002D "-" */ + 0x5, 0x55, 0x55, 0x54, 0x2f, 0xff, 0xff, 0xfd, + 0x2f, 0xff, 0xff, 0xfd, + + /* U+002E "." */ + 0x7a, 0x9b, 0xfe, 0xbf, 0xe0, + + /* U+002F "/" */ + 0x0, 0x0, 0xc, 0xf1, 0x0, 0x0, 0xf, 0xc0, + 0x0, 0x0, 0x5f, 0x80, 0x0, 0x0, 0x9f, 0x30, + 0x0, 0x0, 0xee, 0x0, 0x0, 0x2, 0xfa, 0x0, + 0x0, 0x7, 0xf6, 0x0, 0x0, 0xb, 0xf1, 0x0, + 0x0, 0xf, 0xd0, 0x0, 0x0, 0x4f, 0x80, 0x0, + 0x0, 0x9f, 0x30, 0x0, 0x0, 0xdf, 0x0, 0x0, + 0x2, 0xfa, 0x0, 0x0, 0x7, 0xf6, 0x0, 0x0, + 0xb, 0xf1, 0x0, 0x0, 0xf, 0xd0, 0x0, 0x0, + 0x4f, 0x80, 0x0, 0x0, 0x9f, 0x40, 0x0, 0x0, + 0xdf, 0x0, 0x0, 0x0, + + /* U+0030 "0" */ + 0x0, 0x5, 0xbe, 0xfd, 0x81, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xe1, 0x0, 0x6, 0xff, 0x70, + 0x3, 0xdf, 0xc0, 0x0, 0xef, 0x80, 0x0, 0x2, + 0xff, 0x40, 0x4f, 0xf1, 0x0, 0x0, 0xa, 0xfa, + 0x8, 0xfd, 0x0, 0x0, 0x0, 0x6f, 0xe0, 0xaf, + 0xa0, 0x0, 0x0, 0x4, 0xff, 0xc, 0xf8, 0x0, + 0x0, 0x0, 0x2f, 0xf2, 0xdf, 0x80, 0x0, 0x0, + 0x1, 0xff, 0x3d, 0xf7, 0x0, 0x0, 0x0, 0x1f, + 0xf4, 0xdf, 0x80, 0x0, 0x0, 0x1, 0xff, 0x3c, + 0xf8, 0x0, 0x0, 0x0, 0x2f, 0xf2, 0xaf, 0xa0, + 0x0, 0x0, 0x4, 0xff, 0x8, 0xfd, 0x0, 0x0, + 0x0, 0x6f, 0xe0, 0x4f, 0xf1, 0x0, 0x0, 0xb, + 0xfa, 0x0, 0xef, 0x80, 0x0, 0x2, 0xff, 0x40, + 0x6, 0xff, 0x70, 0x3, 0xef, 0xc0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x5, 0xbe, + 0xfd, 0x81, 0x0, 0x0, + + /* U+0031 "1" */ + 0x0, 0x0, 0x1, 0xfb, 0x0, 0x0, 0xb, 0xfb, + 0x0, 0x0, 0xaf, 0xfb, 0x0, 0x2d, 0xff, 0xfb, + 0x9, 0xff, 0xeb, 0xfb, 0x2f, 0xfb, 0x18, 0xfb, + 0x1b, 0x40, 0x8, 0xfb, 0x0, 0x0, 0x8, 0xfb, + 0x0, 0x0, 0x8, 0xfb, 0x0, 0x0, 0x8, 0xfb, + 0x0, 0x0, 0x8, 0xfb, 0x0, 0x0, 0x8, 0xfb, + 0x0, 0x0, 0x8, 0xfb, 0x0, 0x0, 0x8, 0xfb, + 0x0, 0x0, 0x8, 0xfb, 0x0, 0x0, 0x8, 0xfb, + 0x0, 0x0, 0x8, 0xfb, 0x0, 0x0, 0x8, 0xfb, + 0x0, 0x0, 0x8, 0xfb, + + /* U+0032 "2" */ + 0x0, 0x0, 0x7c, 0xff, 0xea, 0x30, 0x0, 0x0, + 0x2d, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0xdf, + 0xe5, 0x0, 0x2b, 0xff, 0x40, 0x5, 0xff, 0x30, + 0x0, 0x0, 0xbf, 0xc0, 0x9, 0xfc, 0x0, 0x0, + 0x0, 0x5f, 0xf0, 0x5, 0x97, 0x0, 0x0, 0x0, + 0x4f, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0x90, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0x70, 0x0, 0x0, 0x0, 0x1, + 0xcf, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x2d, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x2, 0xef, 0xe3, 0x0, + 0x0, 0x0, 0x0, 0x2e, 0xfe, 0x20, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xe2, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0x63, 0x33, 0x33, 0x33, 0x30, 0xf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0x2f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf1, + + /* U+0033 "3" */ + 0x0, 0x7, 0xdf, 0xfc, 0x70, 0x0, 0x0, 0x1d, + 0xff, 0xff, 0xff, 0xd1, 0x0, 0xb, 0xfe, 0x40, + 0x4, 0xef, 0xb0, 0x3, 0xff, 0x40, 0x0, 0x4, + 0xff, 0x30, 0x8f, 0xd0, 0x0, 0x0, 0xf, 0xf6, + 0x0, 0x12, 0x0, 0x0, 0x0, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xf1, 0x0, 0x0, 0x0, + 0x3, 0x9f, 0xf7, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x4, 0xdd, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0x33, 0x53, 0x0, 0x0, + 0x0, 0x1f, 0xf4, 0xbf, 0xb0, 0x0, 0x0, 0x4, + 0xff, 0x26, 0xff, 0x30, 0x0, 0x0, 0xcf, 0xd0, + 0xd, 0xfe, 0x50, 0x3, 0xcf, 0xf4, 0x0, 0x2e, + 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x17, 0xdf, + 0xfd, 0x81, 0x0, 0x0, + + /* U+0034 "4" */ + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x5, 0xfd, + 0x9f, 0xb0, 0x0, 0x0, 0x0, 0x1e, 0xf3, 0x8f, + 0xb0, 0x0, 0x0, 0x0, 0xbf, 0x70, 0x8f, 0xb0, + 0x0, 0x0, 0x7, 0xfc, 0x0, 0x8f, 0xb0, 0x0, + 0x0, 0x2f, 0xf2, 0x0, 0x8f, 0xb0, 0x0, 0x0, + 0xdf, 0x50, 0x0, 0x8f, 0xb0, 0x0, 0x9, 0xfa, + 0x0, 0x0, 0x8f, 0xb0, 0x0, 0x4f, 0xe1, 0x0, + 0x0, 0x8f, 0xb0, 0x0, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf4, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf4, 0x12, 0x22, 0x22, 0x22, 0x9f, 0xc2, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xb0, 0x0, + + /* U+0035 "5" */ + 0x0, 0xcf, 0xff, 0xff, 0xff, 0xf9, 0x0, 0xe, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x2, 0xff, 0x43, + 0x33, 0x33, 0x32, 0x0, 0x5f, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0x80, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xf6, 0x8d, 0xfe, 0xa3, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xff, 0xf7, 0x0, 0x4f, 0xfe, 0x51, 0x14, + 0xdf, 0xf6, 0x4, 0xcd, 0x10, 0x0, 0x0, 0xdf, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0x75, 0x75, 0x0, 0x0, + 0x0, 0x1f, 0xf5, 0xbf, 0xc0, 0x0, 0x0, 0x5, + 0xff, 0x16, 0xff, 0x40, 0x0, 0x0, 0xdf, 0xb0, + 0xd, 0xfe, 0x50, 0x3, 0xcf, 0xf2, 0x0, 0x2d, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x7, 0xcf, + 0xfd, 0x91, 0x0, 0x0, + + /* U+0036 "6" */ + 0x0, 0x2, 0x9d, 0xff, 0xc6, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xfb, 0x0, 0x2, 0xff, 0x91, + 0x0, 0x7f, 0xf7, 0x0, 0xbf, 0xa0, 0x0, 0x0, + 0xaf, 0xd0, 0x2f, 0xf1, 0x0, 0x0, 0x2, 0x64, + 0x7, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0x80, 0x6c, 0xfe, 0xb4, 0x0, 0xc, 0xf6, 0xbf, + 0xff, 0xff, 0xf7, 0x0, 0xdf, 0xef, 0xa3, 0x13, + 0xcf, 0xf4, 0xe, 0xff, 0x90, 0x0, 0x0, 0xdf, + 0xd0, 0xef, 0xf1, 0x0, 0x0, 0x5, 0xff, 0x2d, + 0xfc, 0x0, 0x0, 0x0, 0x1f, 0xf4, 0xcf, 0xb0, + 0x0, 0x0, 0x0, 0xff, 0x59, 0xfd, 0x0, 0x0, + 0x0, 0x1f, 0xf4, 0x5f, 0xf1, 0x0, 0x0, 0x5, + 0xff, 0x10, 0xef, 0xa0, 0x0, 0x0, 0xdf, 0xb0, + 0x6, 0xff, 0x91, 0x1, 0xaf, 0xf2, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x3, 0xae, + 0xfe, 0xa3, 0x0, 0x0, + + /* U+0037 "7" */ + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5b, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf4, 0x23, 0x33, 0x33, + 0x33, 0x3e, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x4, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0xef, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf4, + 0x0, 0x0, 0x0, 0x0, + + /* U+0038 "8" */ + 0x0, 0x6, 0xcf, 0xfd, 0x92, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x8, 0xff, 0x60, + 0x3, 0xcf, 0xf1, 0x0, 0xef, 0x70, 0x0, 0x1, + 0xff, 0x70, 0x1f, 0xf3, 0x0, 0x0, 0xc, 0xf9, + 0x0, 0xff, 0x70, 0x0, 0x0, 0xff, 0x70, 0xc, + 0xff, 0x50, 0x2, 0xcf, 0xe1, 0x0, 0x2e, 0xff, + 0xff, 0xff, 0xb2, 0x0, 0x0, 0x1c, 0xff, 0xff, + 0xfa, 0x20, 0x0, 0x3e, 0xf6, 0x10, 0x4c, 0xfe, + 0x20, 0x1f, 0xf4, 0x0, 0x0, 0xc, 0xfc, 0x8, + 0xfc, 0x0, 0x0, 0x0, 0x4f, 0xf2, 0xcf, 0x80, + 0x0, 0x0, 0x0, 0xff, 0x4d, 0xf7, 0x0, 0x0, + 0x0, 0xf, 0xf5, 0xcf, 0xb0, 0x0, 0x0, 0x3, + 0xff, 0x37, 0xff, 0x30, 0x0, 0x0, 0xbf, 0xe0, + 0xd, 0xfe, 0x50, 0x2, 0xaf, 0xf5, 0x0, 0x2d, + 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x7, 0xcf, + 0xfd, 0x92, 0x0, 0x0, + + /* U+0039 "9" */ + 0x0, 0x7, 0xdf, 0xfc, 0x60, 0x0, 0x0, 0x2d, + 0xff, 0xff, 0xff, 0xd1, 0x0, 0xd, 0xff, 0x60, + 0x2, 0xcf, 0xd0, 0x5, 0xff, 0x50, 0x0, 0x0, + 0xef, 0x60, 0xaf, 0xc0, 0x0, 0x0, 0x7, 0xfc, + 0xd, 0xf8, 0x0, 0x0, 0x0, 0x4f, 0xf0, 0xdf, + 0x80, 0x0, 0x0, 0x4, 0xff, 0x3b, 0xfb, 0x0, + 0x0, 0x0, 0x6f, 0xf4, 0x7f, 0xf3, 0x0, 0x0, + 0xe, 0xff, 0x50, 0xef, 0xf6, 0x10, 0x3c, 0xff, + 0xf5, 0x3, 0xef, 0xff, 0xff, 0xf5, 0xef, 0x40, + 0x1, 0x9e, 0xfe, 0xa2, 0xf, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xe0, 0x6f, 0xd0, 0x0, 0x0, 0xc, + 0xf9, 0x3, 0xff, 0x20, 0x0, 0x5, 0xff, 0x30, + 0xc, 0xfd, 0x30, 0x6, 0xff, 0x90, 0x0, 0x2e, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x19, 0xdf, + 0xeb, 0x50, 0x0, 0x0, + + /* U+003A ":" */ + 0xbf, 0xeb, 0xfe, 0x7a, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xa9, 0xbf, 0xeb, 0xfe, + + /* U+003B ";" */ + 0xbf, 0xdb, 0xfd, 0x7a, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xa8, 0xbf, 0xdb, 0xfd, 0x7, 0xc0, 0xba, + 0x7f, 0x35, 0x40, + + /* U+003C "<" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x5b, 0xfc, 0x0, 0x0, 0x0, + 0x17, 0xef, 0xff, 0x90, 0x0, 0x2, 0x9f, 0xff, + 0xe8, 0x20, 0x0, 0x5b, 0xff, 0xfc, 0x50, 0x0, + 0x5, 0xef, 0xff, 0x93, 0x0, 0x0, 0x0, 0x9f, + 0xf9, 0x10, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfb, + 0x40, 0x0, 0x0, 0x0, 0x3, 0xaf, 0xff, 0xd7, + 0x0, 0x0, 0x0, 0x0, 0x17, 0xef, 0xff, 0x92, + 0x0, 0x0, 0x0, 0x0, 0x5c, 0xff, 0xfc, 0x40, + 0x0, 0x0, 0x0, 0x3, 0xaf, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x18, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+003D "=" */ + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb8, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0x12, 0x22, 0x22, + 0x22, 0x22, 0x22, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xb8, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfb, + + /* U+003E ">" */ + 0x54, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xfd, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xe8, + 0x20, 0x0, 0x0, 0x0, 0x17, 0xdf, 0xff, 0xb4, + 0x0, 0x0, 0x0, 0x0, 0x4b, 0xff, 0xfd, 0x60, + 0x0, 0x0, 0x0, 0x2, 0x8e, 0xff, 0xe7, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x39, 0xff, 0xfa, 0x0, 0x0, 0x5, 0xcf, + 0xff, 0xb4, 0x0, 0x1, 0x8e, 0xff, 0xf9, 0x20, + 0x0, 0x3a, 0xff, 0xfd, 0x71, 0x0, 0x0, 0x9, + 0xff, 0xc5, 0x0, 0x0, 0x0, 0x0, 0x89, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+003F "?" */ + 0x0, 0x7, 0xcf, 0xfe, 0xa3, 0x0, 0x0, 0x1d, + 0xff, 0xfe, 0xff, 0xf8, 0x0, 0xd, 0xff, 0x60, + 0x2, 0xaf, 0xf6, 0x5, 0xff, 0x50, 0x0, 0x0, + 0xbf, 0xe0, 0xaf, 0xd0, 0x0, 0x0, 0x4, 0xff, + 0x25, 0x86, 0x0, 0x0, 0x0, 0x2f, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0x80, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x5, 0x61, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xa5, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xf8, 0x0, 0x0, 0x0, + + /* U+0040 "@" */ + 0x0, 0x0, 0x0, 0x0, 0x49, 0xcd, 0xff, 0xec, + 0x83, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xef, 0xff, 0xfe, 0xef, 0xff, 0xfc, 0x30, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xc6, 0x20, 0x0, + 0x3, 0x7e, 0xff, 0x60, 0x0, 0x0, 0x0, 0x1c, + 0xfd, 0x40, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0x60, 0x0, 0x0, 0xb, 0xfc, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0x30, 0x0, 0x6, + 0xfd, 0x0, 0x0, 0x5c, 0xfe, 0xa2, 0xe, 0xf5, + 0x6, 0xfc, 0x0, 0x0, 0xff, 0x20, 0x0, 0x9f, + 0xff, 0xff, 0xe3, 0xff, 0x20, 0xc, 0xf4, 0x0, + 0x7f, 0x80, 0x0, 0x9f, 0xf6, 0x0, 0x6f, 0xef, + 0xe0, 0x0, 0x6f, 0x90, 0xd, 0xf1, 0x0, 0x4f, + 0xf4, 0x0, 0x0, 0x7f, 0xfb, 0x0, 0x1, 0xfc, + 0x1, 0xfc, 0x0, 0xd, 0xfa, 0x0, 0x0, 0x2, + 0xff, 0x80, 0x0, 0xf, 0xd0, 0x5f, 0x80, 0x3, + 0xff, 0x30, 0x0, 0x0, 0xf, 0xf4, 0x0, 0x1, + 0xfd, 0x6, 0xf7, 0x0, 0x7f, 0xe0, 0x0, 0x0, + 0x1, 0xff, 0x10, 0x0, 0x3f, 0xb0, 0x8f, 0x60, + 0xa, 0xfb, 0x0, 0x0, 0x0, 0x4f, 0xe0, 0x0, + 0x8, 0xf7, 0x7, 0xf6, 0x0, 0xaf, 0xb0, 0x0, + 0x0, 0x9, 0xfb, 0x0, 0x0, 0xef, 0x20, 0x6f, + 0x80, 0x9, 0xfd, 0x0, 0x0, 0x2, 0xff, 0x70, + 0x0, 0x8f, 0xa0, 0x3, 0xfb, 0x0, 0x5f, 0xf4, + 0x0, 0x1, 0xdf, 0xf4, 0x0, 0x7f, 0xe1, 0x0, + 0xe, 0xf1, 0x0, 0xef, 0xe6, 0x26, 0xef, 0xff, + 0x83, 0xbf, 0xf4, 0x0, 0x0, 0x9f, 0x80, 0x3, + 0xff, 0xff, 0xfe, 0x4f, 0xff, 0xff, 0xe3, 0x0, + 0x0, 0x1, 0xff, 0x30, 0x3, 0xbf, 0xea, 0x10, + 0x6e, 0xfd, 0x81, 0x0, 0x44, 0x10, 0x6, 0xfe, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xe1, 0x0, 0x9, 0xff, 0x81, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xcf, 0xe3, 0x0, 0x0, + 0x7, 0xff, 0xfa, 0x52, 0x0, 0x0, 0x13, 0x7c, + 0xff, 0xc2, 0x0, 0x0, 0x0, 0x2, 0xaf, 0xff, + 0xff, 0xfe, 0xff, 0xff, 0xfd, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x16, 0x9c, 0xef, 0xff, 0xeb, + 0x83, 0x0, 0x0, 0x0, + + /* U+0041 "A" */ + 0x0, 0x0, 0x0, 0x1, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfb, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0x2f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xb0, 0xcf, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xf6, 0x6, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0x10, 0x1f, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xa0, 0x0, + 0xaf, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf4, + 0x0, 0x4, 0xff, 0x30, 0x0, 0x0, 0x0, 0x7, + 0xfe, 0x0, 0x0, 0xe, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0x80, 0x0, 0x0, 0x8f, 0xf0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0xef, 0x80, 0x0, + 0x0, 0x0, 0x6f, 0xf3, 0x0, 0x0, 0x5f, 0xf2, + 0x0, 0x0, 0x0, 0x1, 0xff, 0x90, 0x0, 0xb, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0x0, + 0x1, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xf6, 0x0, 0x7f, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xc0, 0xd, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0x30, + + /* U+0042 "B" */ + 0x1f, 0xff, 0xff, 0xff, 0xfd, 0xa4, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x1f, + 0xf8, 0x33, 0x34, 0x47, 0xdf, 0xf6, 0x1, 0xff, + 0x60, 0x0, 0x0, 0x0, 0xdf, 0xd0, 0x1f, 0xf6, + 0x0, 0x0, 0x0, 0x7, 0xff, 0x1, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x6f, 0xf0, 0x1f, 0xf6, 0x0, + 0x0, 0x0, 0xa, 0xfb, 0x1, 0xff, 0x60, 0x0, + 0x0, 0x39, 0xff, 0x30, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x30, 0x1, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x10, 0x1f, 0xf8, 0x33, 0x33, 0x46, + 0xaf, 0xfd, 0x1, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x4f, 0xf8, 0x1f, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xd1, 0xff, 0x60, 0x0, 0x0, 0x0, 0x9, + 0xff, 0x1f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xd1, 0xff, 0x60, 0x0, 0x0, 0x0, 0x3f, 0xf9, + 0x1f, 0xf8, 0x33, 0x33, 0x45, 0x9f, 0xff, 0x21, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, 0x1f, + 0xff, 0xff, 0xff, 0xfe, 0xc8, 0x10, 0x0, + + /* U+0043 "C" */ + 0x0, 0x0, 0x4, 0xad, 0xff, 0xea, 0x40, 0x0, + 0x0, 0x0, 0x2c, 0xff, 0xff, 0xff, 0xff, 0xc1, + 0x0, 0x0, 0x3f, 0xff, 0xa5, 0x33, 0x5b, 0xff, + 0xd1, 0x0, 0x1e, 0xfe, 0x30, 0x0, 0x0, 0x6, + 0xff, 0xa0, 0x9, 0xff, 0x30, 0x0, 0x0, 0x0, + 0xa, 0xff, 0x21, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x2d, 0x92, 0x5f, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x97, 0x30, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf9, 0x9, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x9, 0xff, 0x30, + 0x1e, 0xfe, 0x30, 0x0, 0x0, 0x7, 0xff, 0xa0, + 0x0, 0x4f, 0xff, 0x94, 0x22, 0x5c, 0xff, 0xd1, + 0x0, 0x0, 0x4e, 0xff, 0xff, 0xff, 0xff, 0xb1, + 0x0, 0x0, 0x0, 0x6, 0xbd, 0xff, 0xea, 0x40, + 0x0, 0x0, + + /* U+0044 "D" */ + 0xff, 0xff, 0xff, 0xff, 0xeb, 0x71, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, + 0xff, 0x93, 0x33, 0x34, 0x6a, 0xff, 0xf4, 0x0, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x2e, 0xfe, 0x10, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x4, 0xff, 0x70, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xd0, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf2, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf4, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xf5, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf6, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xf6, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf4, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf1, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xd0, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x4, 0xff, 0x70, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x2e, 0xfe, 0x0, + 0xff, 0x93, 0x33, 0x34, 0x6a, 0xff, 0xf4, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x40, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xda, 0x60, 0x0, 0x0, + + /* U+0045 "E" */ + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xff, 0xa3, + 0x33, 0x33, 0x33, 0x33, 0x31, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0xff, 0x93, + 0x33, 0x33, 0x33, 0x33, 0x20, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xa3, 0x33, 0x33, 0x33, 0x33, 0x33, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, + + /* U+0046 "F" */ + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xae, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0xef, 0xa3, 0x33, + 0x33, 0x33, 0x33, 0x2e, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0x80, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0x80, 0x0, 0x0, 0x0, 0x0, 0xe, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xf4, 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x40, 0xef, 0xa3, 0x33, 0x33, 0x33, 0x31, 0xe, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0x80, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0x80, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0x80, 0x0, 0x0, 0x0, 0x0, 0xe, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0047 "G" */ + 0x0, 0x0, 0x3, 0x8c, 0xef, 0xfd, 0xa4, 0x0, + 0x0, 0x0, 0x1, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xb1, 0x0, 0x0, 0x2d, 0xff, 0xc6, 0x32, 0x36, + 0xcf, 0xfd, 0x0, 0x0, 0xcf, 0xf5, 0x0, 0x0, + 0x0, 0x6, 0xff, 0x80, 0x7, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf0, 0xe, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2c, 0x81, 0x3f, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xe0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xf9, 0x9f, 0xf0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xf9, 0x7f, 0xf1, 0x0, 0x0, 0x1, + 0x33, 0x33, 0x3e, 0xf9, 0x4f, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xf9, 0xe, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xf9, 0x7, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0xd, 0xf9, 0x0, + 0xcf, 0xf8, 0x0, 0x0, 0x0, 0x3, 0xcf, 0xf9, + 0x0, 0x1d, 0xff, 0xe9, 0x54, 0x57, 0xcf, 0xff, + 0xc2, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xe6, 0x0, 0x0, 0x0, 0x2, 0x8c, 0xef, 0xfd, + 0xa5, 0x0, 0x0, + + /* U+0048 "H" */ + 0xef, 0x80, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xbe, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfb, 0xef, + 0x80, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xbe, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xfb, 0xef, 0x80, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xbe, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xfb, 0xef, 0x80, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xbe, 0xfa, 0x33, 0x33, + 0x33, 0x33, 0x3d, 0xfb, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xbe, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0xef, 0x80, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xbe, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xfb, 0xef, 0x80, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xbe, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xfb, 0xef, 0x80, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xbe, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfb, + 0xef, 0x80, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xbe, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfb, 0xef, + 0x80, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xb0, + + /* U+0049 "I" */ + 0x9f, 0xd9, 0xfd, 0x9f, 0xd9, 0xfd, 0x9f, 0xd9, + 0xfd, 0x9f, 0xd9, 0xfd, 0x9f, 0xd9, 0xfd, 0x9f, + 0xd9, 0xfd, 0x9f, 0xd9, 0xfd, 0x9f, 0xd9, 0xfd, + 0x9f, 0xd9, 0xfd, 0x9f, 0xd0, + + /* U+004A "J" */ + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xf0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xf0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xf0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf2, + 0xbe, 0x0, 0x0, 0x8, 0xff, 0x3f, 0xf2, 0x0, + 0x0, 0x9f, 0xd0, 0xff, 0x80, 0x0, 0xe, 0xfa, + 0xa, 0xff, 0x94, 0x5c, 0xff, 0x50, 0x2e, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x19, 0xef, 0xfb, 0x50, + 0x0, + + /* U+004B "K" */ + 0x1f, 0xf6, 0x0, 0x0, 0x0, 0x1, 0xcf, 0xf7, + 0x1, 0xff, 0x60, 0x0, 0x0, 0x0, 0xcf, 0xf7, + 0x0, 0x1f, 0xf6, 0x0, 0x0, 0x0, 0xcf, 0xf6, + 0x0, 0x1, 0xff, 0x60, 0x0, 0x0, 0xcf, 0xf6, + 0x0, 0x0, 0x1f, 0xf6, 0x0, 0x0, 0xcf, 0xf6, + 0x0, 0x0, 0x1, 0xff, 0x60, 0x0, 0xbf, 0xf6, + 0x0, 0x0, 0x0, 0x1f, 0xf6, 0x0, 0xbf, 0xf6, + 0x0, 0x0, 0x0, 0x1, 0xff, 0x60, 0xbf, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf6, 0xbf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xef, 0xfb, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf5, + 0xc, 0xff, 0x30, 0x0, 0x0, 0x1, 0xff, 0xf5, + 0x0, 0x2f, 0xfd, 0x0, 0x0, 0x0, 0x1f, 0xf7, + 0x0, 0x0, 0x6f, 0xf9, 0x0, 0x0, 0x1, 0xff, + 0x60, 0x0, 0x0, 0xbf, 0xf5, 0x0, 0x0, 0x1f, + 0xf6, 0x0, 0x0, 0x1, 0xff, 0xe1, 0x0, 0x1, + 0xff, 0x60, 0x0, 0x0, 0x5, 0xff, 0xc0, 0x0, + 0x1f, 0xf6, 0x0, 0x0, 0x0, 0xa, 0xff, 0x70, + 0x1, 0xff, 0x60, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0x30, 0x1f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xfd, 0x0, + + /* U+004C "L" */ + 0xf, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0xf, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xf, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xf8, 0x33, 0x33, 0x33, 0x33, 0x20, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0xf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x90, + + /* U+004D "M" */ + 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xb0, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xfb, 0xf, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xb0, 0xff, 0xcf, 0xc0, + 0x0, 0x0, 0x0, 0xc, 0xfd, 0xfb, 0xf, 0xf7, + 0xff, 0x20, 0x0, 0x0, 0x1, 0xfd, 0xaf, 0xb0, + 0xff, 0x5c, 0xf7, 0x0, 0x0, 0x0, 0x7f, 0x8a, + 0xfb, 0xf, 0xf5, 0x7f, 0xc0, 0x0, 0x0, 0xc, + 0xf2, 0xaf, 0xb0, 0xff, 0x51, 0xff, 0x10, 0x0, + 0x1, 0xfd, 0xa, 0xfb, 0xf, 0xf5, 0xc, 0xf7, + 0x0, 0x0, 0x7f, 0x80, 0xaf, 0xb0, 0xff, 0x50, + 0x7f, 0xc0, 0x0, 0xc, 0xf2, 0xa, 0xfb, 0xf, + 0xf5, 0x1, 0xff, 0x10, 0x2, 0xfd, 0x0, 0xaf, + 0xb0, 0xff, 0x50, 0xc, 0xf6, 0x0, 0x7f, 0x70, + 0xa, 0xfb, 0xf, 0xf5, 0x0, 0x7f, 0xc0, 0xc, + 0xf2, 0x0, 0xaf, 0xb0, 0xff, 0x50, 0x1, 0xff, + 0x12, 0xfc, 0x0, 0xa, 0xfb, 0xf, 0xf5, 0x0, + 0xc, 0xf6, 0x7f, 0x70, 0x0, 0xaf, 0xb0, 0xff, + 0x50, 0x0, 0x7f, 0xbc, 0xf2, 0x0, 0xa, 0xfb, + 0xf, 0xf5, 0x0, 0x1, 0xff, 0xfc, 0x0, 0x0, + 0xaf, 0xb0, 0xff, 0x50, 0x0, 0xc, 0xff, 0x70, + 0x0, 0xa, 0xfb, 0xf, 0xf5, 0x0, 0x0, 0x7f, + 0xf1, 0x0, 0x0, 0xaf, 0xb0, + + /* U+004E "N" */ + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xbf, + 0xff, 0x80, 0x0, 0x0, 0x0, 0xa, 0xfb, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0xaf, 0xbf, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0xa, 0xfb, 0xff, 0xbf, + 0xf8, 0x0, 0x0, 0x0, 0xaf, 0xbf, 0xf6, 0xaf, + 0xf3, 0x0, 0x0, 0xa, 0xfb, 0xff, 0x61, 0xef, + 0xd0, 0x0, 0x0, 0xaf, 0xbf, 0xf6, 0x5, 0xff, + 0x70, 0x0, 0xa, 0xfb, 0xff, 0x60, 0xa, 0xff, + 0x20, 0x0, 0xaf, 0xbf, 0xf6, 0x0, 0x1e, 0xfc, + 0x0, 0xa, 0xfb, 0xff, 0x60, 0x0, 0x5f, 0xf7, + 0x0, 0xaf, 0xbf, 0xf6, 0x0, 0x0, 0xbf, 0xf2, + 0xa, 0xfb, 0xff, 0x60, 0x0, 0x1, 0xff, 0xc0, + 0xaf, 0xbf, 0xf6, 0x0, 0x0, 0x6, 0xff, 0x6a, + 0xfb, 0xff, 0x60, 0x0, 0x0, 0xc, 0xff, 0xcf, + 0xbf, 0xf6, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfb, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xbf, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfb, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x2, 0xff, 0xb0, + + /* U+004F "O" */ + 0x0, 0x0, 0x4, 0x9d, 0xff, 0xeb, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x2c, 0xff, 0xff, 0xff, 0xff, + 0xd4, 0x0, 0x0, 0x0, 0x3e, 0xff, 0xb5, 0x32, + 0x49, 0xff, 0xf5, 0x0, 0x0, 0x1e, 0xfe, 0x40, + 0x0, 0x0, 0x2, 0xdf, 0xf3, 0x0, 0x9, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x1, 0xef, 0xd0, 0x1, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0x40, 0x5f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xf9, 0x9, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xd0, 0xbf, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xfe, 0xc, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf0, 0xbf, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0x9, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xd0, 0x5f, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xf9, 0x0, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0x40, 0xa, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xd0, 0x0, 0x1e, + 0xfe, 0x30, 0x0, 0x0, 0x2, 0xdf, 0xf3, 0x0, + 0x0, 0x3f, 0xff, 0xa5, 0x32, 0x49, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x2c, 0xff, 0xff, 0xff, 0xff, + 0xd4, 0x0, 0x0, 0x0, 0x0, 0x4, 0xad, 0xff, + 0xeb, 0x60, 0x0, 0x0, 0x0, + + /* U+0050 "P" */ + 0xff, 0xff, 0xff, 0xff, 0xed, 0xa4, 0x0, 0xf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0xff, + 0x93, 0x33, 0x33, 0x47, 0xdf, 0xf6, 0xf, 0xf7, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xd0, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x8, 0xff, 0x1f, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf3, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x7, 0xff, 0x1f, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xe0, 0xff, 0x70, 0x0, 0x0, + 0x15, 0xcf, 0xf6, 0xf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xc6, 0x0, 0xf, 0xf9, 0x33, 0x33, 0x32, 0x0, + 0x0, 0x0, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0051 "Q" */ + 0x0, 0x0, 0x4, 0x9d, 0xff, 0xeb, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x2c, 0xff, 0xff, 0xff, 0xff, + 0xe4, 0x0, 0x0, 0x0, 0x3e, 0xff, 0xa5, 0x32, + 0x49, 0xff, 0xf6, 0x0, 0x0, 0x1e, 0xfe, 0x30, + 0x0, 0x0, 0x1, 0xdf, 0xf4, 0x0, 0x9, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x1, 0xef, 0xd0, 0x1, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0x40, 0x5f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xf9, 0x9, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xd0, 0xbf, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xc, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf0, 0xbf, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xfe, + 0x9, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xd0, 0x5f, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xf9, 0x1, 0xff, 0x90, 0x0, 0x0, + 0x23, 0x0, 0x5, 0xff, 0x40, 0x9, 0xff, 0x30, + 0x0, 0x8, 0xfd, 0x31, 0xef, 0xd0, 0x0, 0xd, + 0xfe, 0x40, 0x0, 0x5c, 0xff, 0xef, 0xf3, 0x0, + 0x0, 0x3e, 0xff, 0xa5, 0x32, 0x4d, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x2c, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x5, 0xad, 0xff, + 0xea, 0x50, 0x6f, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x29, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0052 "R" */ + 0xef, 0xff, 0xff, 0xff, 0xfe, 0xda, 0x30, 0x0, + 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, + 0x0, 0xef, 0x91, 0x11, 0x11, 0x12, 0x6e, 0xff, + 0x20, 0xe, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xfa, 0x0, 0xef, 0x80, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xd0, 0xe, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0x0, 0xef, 0x80, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xd0, 0xe, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xf8, 0x0, 0xef, 0x92, 0x22, 0x22, + 0x35, 0x9f, 0xfe, 0x10, 0xe, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x20, 0x0, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xa5, 0x0, 0x0, 0xe, 0xf8, 0x0, + 0x2, 0x7e, 0xfc, 0x10, 0x0, 0x0, 0xef, 0x80, + 0x0, 0x0, 0x2f, 0xfd, 0x10, 0x0, 0xe, 0xf8, + 0x0, 0x0, 0x0, 0x5f, 0xfc, 0x0, 0x0, 0xef, + 0x80, 0x0, 0x0, 0x0, 0x9f, 0xf8, 0x0, 0xe, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf3, 0x0, + 0xef, 0x80, 0x0, 0x0, 0x0, 0x4, 0xff, 0xc0, + 0xe, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0x70, 0xef, 0x80, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0x20, + + /* U+0053 "S" */ + 0x0, 0x2, 0x8c, 0xff, 0xec, 0x82, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x5, + 0xff, 0xe7, 0x53, 0x57, 0xef, 0xf6, 0x0, 0xdf, + 0xc0, 0x0, 0x0, 0x0, 0xdf, 0xe0, 0x1f, 0xf5, + 0x0, 0x0, 0x0, 0x4, 0xff, 0x40, 0xff, 0x50, + 0x0, 0x0, 0x0, 0xa, 0x93, 0xd, 0xfd, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xb6, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x5e, 0xff, 0xff, + 0xea, 0x61, 0x0, 0x0, 0x0, 0x16, 0xbf, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x4, 0x8c, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xaf, 0xf7, 0x35, 0x30, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xdb, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0x8f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xd2, 0xff, 0xd2, 0x0, 0x0, 0x0, 0x3f, 0xf9, + 0x7, 0xff, 0xfb, 0x64, 0x46, 0xbf, 0xfe, 0x10, + 0x7, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x20, 0x0, + 0x1, 0x7b, 0xef, 0xfe, 0xb5, 0x0, 0x0, + + /* U+0054 "T" */ + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x13, 0x33, 0x33, 0x7f, 0xf5, 0x33, 0x33, 0x31, + 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x0, + + /* U+0055 "U" */ + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xbf, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfb, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xbf, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xfb, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xbf, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xfb, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xbf, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xfb, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xbf, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xfb, 0xef, 0x80, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xbe, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xfa, 0xdf, 0x90, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0x9b, 0xfc, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xf8, 0x7f, 0xf1, 0x0, 0x0, 0x0, 0x5, 0xff, + 0x42, 0xff, 0xb0, 0x0, 0x0, 0x1, 0xdf, 0xe0, + 0x9, 0xff, 0xe8, 0x54, 0x59, 0xff, 0xf6, 0x0, + 0xa, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x4, 0xad, 0xff, 0xfc, 0x82, 0x0, 0x0, + + /* U+0056 "V" */ + 0xbf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xe0, 0x4f, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0x90, 0xe, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0x30, 0x8, 0xff, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xfc, 0x0, 0x2, 0xff, 0x50, 0x0, + 0x0, 0x0, 0xf, 0xf6, 0x0, 0x0, 0xcf, 0xb0, + 0x0, 0x0, 0x0, 0x5f, 0xf1, 0x0, 0x0, 0x6f, + 0xf1, 0x0, 0x0, 0x0, 0xbf, 0xa0, 0x0, 0x0, + 0xf, 0xf6, 0x0, 0x0, 0x1, 0xff, 0x40, 0x0, + 0x0, 0xa, 0xfc, 0x0, 0x0, 0x7, 0xfe, 0x0, + 0x0, 0x0, 0x4, 0xff, 0x10, 0x0, 0xd, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xef, 0x70, 0x0, 0x3f, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xd0, 0x0, + 0x8f, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xf2, + 0x0, 0xef, 0x50, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xf8, 0x4, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xfd, 0x9, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0x3e, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xbf, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0x10, + 0x0, 0x0, 0x0, + + /* U+0057 "W" */ + 0x9f, 0xe0, 0x0, 0x0, 0x0, 0x5f, 0xfe, 0x0, + 0x0, 0x0, 0x6, 0xff, 0x15, 0xff, 0x20, 0x0, + 0x0, 0x9, 0xff, 0xf2, 0x0, 0x0, 0x0, 0xaf, + 0xc0, 0x1f, 0xf5, 0x0, 0x0, 0x0, 0xef, 0xef, + 0x70, 0x0, 0x0, 0xe, 0xf8, 0x0, 0xdf, 0x90, + 0x0, 0x0, 0x2f, 0xe7, 0xfb, 0x0, 0x0, 0x1, + 0xff, 0x40, 0x9, 0xfd, 0x0, 0x0, 0x7, 0xfa, + 0x3f, 0xf0, 0x0, 0x0, 0x5f, 0xf0, 0x0, 0x4f, + 0xf0, 0x0, 0x0, 0xbf, 0x60, 0xef, 0x40, 0x0, + 0x9, 0xfb, 0x0, 0x0, 0xff, 0x40, 0x0, 0xf, + 0xf2, 0xa, 0xf8, 0x0, 0x0, 0xdf, 0x70, 0x0, + 0xc, 0xf7, 0x0, 0x4, 0xfd, 0x0, 0x6f, 0xd0, + 0x0, 0x1f, 0xf2, 0x0, 0x0, 0x8f, 0xb0, 0x0, + 0x8f, 0x90, 0x2, 0xff, 0x10, 0x5, 0xfe, 0x0, + 0x0, 0x4, 0xff, 0x0, 0xd, 0xf5, 0x0, 0xd, + 0xf6, 0x0, 0x8f, 0xa0, 0x0, 0x0, 0xf, 0xf2, + 0x1, 0xff, 0x0, 0x0, 0x9f, 0xa0, 0xc, 0xf6, + 0x0, 0x0, 0x0, 0xbf, 0x60, 0x6f, 0xc0, 0x0, + 0x5, 0xfe, 0x0, 0xff, 0x10, 0x0, 0x0, 0x7, + 0xfa, 0xa, 0xf7, 0x0, 0x0, 0xf, 0xf2, 0x4f, + 0xd0, 0x0, 0x0, 0x0, 0x3f, 0xd0, 0xef, 0x30, + 0x0, 0x0, 0xcf, 0x58, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0xff, 0x3f, 0xe0, 0x0, 0x0, 0x8, 0xf8, + 0xbf, 0x40, 0x0, 0x0, 0x0, 0xb, 0xfa, 0xfa, + 0x0, 0x0, 0x0, 0x3f, 0xbf, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0xb, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xf3, 0x0, 0x0, 0x0, + + /* U+0058 "X" */ + 0xa, 0xff, 0x30, 0x0, 0x0, 0x0, 0x6, 0xff, + 0x40, 0x1, 0xef, 0xe0, 0x0, 0x0, 0x0, 0x2f, + 0xf9, 0x0, 0x0, 0x4f, 0xfa, 0x0, 0x0, 0x0, + 0xdf, 0xd0, 0x0, 0x0, 0x9, 0xff, 0x50, 0x0, + 0x9, 0xff, 0x20, 0x0, 0x0, 0x0, 0xdf, 0xe1, + 0x0, 0x5f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xfb, 0x1, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0x5b, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x6e, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfa, + 0x5, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xe1, 0x0, 0xaf, 0xf5, 0x0, 0x0, 0x0, 0x9, + 0xff, 0x40, 0x0, 0x1e, 0xfe, 0x10, 0x0, 0x0, + 0x5f, 0xf8, 0x0, 0x0, 0x4, 0xff, 0xb0, 0x0, + 0x2, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x9f, 0xf6, + 0x0, 0xc, 0xff, 0x20, 0x0, 0x0, 0x0, 0xd, + 0xff, 0x20, 0x8f, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xc0, + + /* U+0059 "Y" */ + 0x9f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xc0, 0xe, 0xfe, 0x10, 0x0, 0x0, 0x0, 0xb, + 0xff, 0x20, 0x4, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x5f, 0xf7, 0x0, 0x0, 0xaf, 0xf4, 0x0, 0x0, + 0x1, 0xef, 0xc0, 0x0, 0x0, 0x1e, 0xfe, 0x0, + 0x0, 0xa, 0xff, 0x20, 0x0, 0x0, 0x5, 0xff, + 0x90, 0x0, 0x4f, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xf3, 0x0, 0xdf, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xfc, 0x8, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0x8f, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfb, 0x0, + 0x0, 0x0, 0x0, + + /* U+005A "Z" */ + 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, + 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, + 0x1, 0x33, 0x33, 0x33, 0x33, 0x38, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xdf, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2e, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xfb, 0x33, 0x33, 0x33, 0x33, 0x33, 0x30, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, + + /* U+005B "[" */ + 0x4f, 0xff, 0xfc, 0x4f, 0xfe, 0xeb, 0x4f, 0xf0, + 0x0, 0x4f, 0xf0, 0x0, 0x4f, 0xf0, 0x0, 0x4f, + 0xf0, 0x0, 0x4f, 0xf0, 0x0, 0x4f, 0xf0, 0x0, + 0x4f, 0xf0, 0x0, 0x4f, 0xf0, 0x0, 0x4f, 0xf0, + 0x0, 0x4f, 0xf0, 0x0, 0x4f, 0xf0, 0x0, 0x4f, + 0xf0, 0x0, 0x4f, 0xf0, 0x0, 0x4f, 0xf0, 0x0, + 0x4f, 0xf0, 0x0, 0x4f, 0xf0, 0x0, 0x4f, 0xf0, + 0x0, 0x4f, 0xf0, 0x0, 0x4f, 0xf0, 0x0, 0x4f, + 0xf0, 0x0, 0x4f, 0xfe, 0xeb, 0x4f, 0xff, 0xfc, + + /* U+005C "\\" */ + 0xdf, 0x0, 0x0, 0x0, 0x9f, 0x40, 0x0, 0x0, + 0x4f, 0x80, 0x0, 0x0, 0xf, 0xd0, 0x0, 0x0, + 0xb, 0xf1, 0x0, 0x0, 0x7, 0xf6, 0x0, 0x0, + 0x2, 0xfa, 0x0, 0x0, 0x0, 0xdf, 0x0, 0x0, + 0x0, 0x9f, 0x30, 0x0, 0x0, 0x4f, 0x80, 0x0, + 0x0, 0xf, 0xd0, 0x0, 0x0, 0xb, 0xf1, 0x0, + 0x0, 0x7, 0xf6, 0x0, 0x0, 0x2, 0xfa, 0x0, + 0x0, 0x0, 0xee, 0x0, 0x0, 0x0, 0x9f, 0x30, + 0x0, 0x0, 0x5f, 0x80, 0x0, 0x0, 0xf, 0xc0, + 0x0, 0x0, 0xc, 0xf1, + + /* U+005D "]" */ + 0x8f, 0xff, 0xf8, 0x8e, 0xef, 0xf8, 0x0, 0xc, + 0xf8, 0x0, 0xc, 0xf8, 0x0, 0xc, 0xf8, 0x0, + 0xc, 0xf8, 0x0, 0xc, 0xf8, 0x0, 0xc, 0xf8, + 0x0, 0xc, 0xf8, 0x0, 0xc, 0xf8, 0x0, 0xc, + 0xf8, 0x0, 0xc, 0xf8, 0x0, 0xc, 0xf8, 0x0, + 0xc, 0xf8, 0x0, 0xc, 0xf8, 0x0, 0xc, 0xf8, + 0x0, 0xc, 0xf8, 0x0, 0xc, 0xf8, 0x0, 0xc, + 0xf8, 0x0, 0xc, 0xf8, 0x0, 0xc, 0xf8, 0x0, + 0xc, 0xf8, 0x8e, 0xef, 0xf8, 0x8f, 0xff, 0xf8, + + /* U+005E "^" */ + 0x0, 0x0, 0x7, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfd, + 0x0, 0x0, 0x0, 0x1, 0xfe, 0xcf, 0x40, 0x0, + 0x0, 0x8, 0xf8, 0x6f, 0xb0, 0x0, 0x0, 0xe, + 0xf2, 0xf, 0xf2, 0x0, 0x0, 0x6f, 0xc0, 0x9, + 0xf9, 0x0, 0x0, 0xdf, 0x60, 0x2, 0xff, 0x0, + 0x3, 0xff, 0x0, 0x0, 0xcf, 0x70, 0xa, 0xf9, + 0x0, 0x0, 0x6f, 0xd0, 0x1f, 0xf3, 0x0, 0x0, + 0xf, 0xf4, + + /* U+005F "_" */ + 0x1a, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xa6, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + + /* U+0060 "`" */ + 0x69, 0x93, 0x1, 0xef, 0xb0, 0x3, 0xff, 0x30, + 0x5, 0xfa, + + /* U+0061 "a" */ + 0x0, 0x2, 0x8d, 0xff, 0xfc, 0x70, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x1, 0xff, + 0xb2, 0x0, 0x18, 0xff, 0x60, 0x7, 0xff, 0x0, + 0x0, 0x0, 0xdf, 0x90, 0x1, 0x44, 0x0, 0x0, + 0x0, 0xaf, 0xa0, 0x0, 0x0, 0x0, 0x2, 0x58, + 0xef, 0xa0, 0x0, 0x5, 0xae, 0xff, 0xff, 0xff, + 0xb0, 0x1, 0xcf, 0xff, 0xda, 0x74, 0xaf, 0xb0, + 0xa, 0xff, 0x60, 0x0, 0x0, 0xaf, 0xb0, 0xf, + 0xf8, 0x0, 0x0, 0x0, 0xdf, 0xb0, 0xf, 0xf8, + 0x0, 0x0, 0x4, 0xff, 0xb0, 0xc, 0xfe, 0x30, + 0x0, 0x7f, 0xff, 0xb0, 0x3, 0xff, 0xfe, 0xdf, + 0xff, 0xaf, 0xd0, 0x0, 0x2a, 0xef, 0xfc, 0x81, + 0x2f, 0xf2, + + /* U+0062 "b" */ + 0x4f, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0x6, 0xdf, 0xeb, 0x40, 0x0, 0x4f, + 0xfa, 0xff, 0xef, 0xff, 0x70, 0x4, 0xff, 0xfa, + 0x10, 0x19, 0xff, 0x40, 0x4f, 0xfc, 0x0, 0x0, + 0xc, 0xfc, 0x4, 0xff, 0x40, 0x0, 0x0, 0x5f, + 0xf2, 0x4f, 0xf0, 0x0, 0x0, 0x0, 0xff, 0x54, + 0xfe, 0x0, 0x0, 0x0, 0xf, 0xf6, 0x4f, 0xd0, + 0x0, 0x0, 0x0, 0xff, 0x64, 0xfe, 0x0, 0x0, + 0x0, 0x1f, 0xf4, 0x4f, 0xf2, 0x0, 0x0, 0x5, + 0xff, 0x14, 0xff, 0xa0, 0x0, 0x0, 0xcf, 0xb0, + 0x4f, 0xff, 0x91, 0x1, 0xaf, 0xf3, 0x4, 0xfe, + 0xaf, 0xfe, 0xff, 0xf5, 0x0, 0x4f, 0xe0, 0x7d, + 0xfe, 0xa2, 0x0, 0x0, + + /* U+0063 "c" */ + 0x0, 0x7, 0xcf, 0xfd, 0x81, 0x0, 0x1, 0xdf, + 0xff, 0xff, 0xfe, 0x30, 0xc, 0xfe, 0x50, 0x2, + 0xdf, 0xe0, 0x5f, 0xf3, 0x0, 0x0, 0x2f, 0xf5, + 0xaf, 0xb0, 0x0, 0x0, 0x6, 0x62, 0xdf, 0x70, + 0x0, 0x0, 0x0, 0x0, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0xef, 0x70, 0x0, 0x0, 0x1, 0x10, 0xaf, 0xb0, + 0x0, 0x0, 0xa, 0xfa, 0x5f, 0xf2, 0x0, 0x0, + 0x1f, 0xf5, 0xc, 0xfd, 0x40, 0x3, 0xcf, 0xd0, + 0x1, 0xdf, 0xff, 0xff, 0xfe, 0x20, 0x0, 0x7, + 0xcf, 0xfd, 0x80, 0x0, + + /* U+0064 "d" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xa0, 0x0, 0x19, 0xdf, 0xe9, 0x1a, 0xfa, 0x0, + 0x2e, 0xff, 0xff, 0xfe, 0xcf, 0xa0, 0xd, 0xfd, + 0x30, 0x5, 0xff, 0xfa, 0x6, 0xff, 0x20, 0x0, + 0x5, 0xff, 0xa0, 0xcf, 0xa0, 0x0, 0x0, 0xe, + 0xfa, 0xf, 0xf6, 0x0, 0x0, 0x0, 0xaf, 0xa0, + 0xff, 0x40, 0x0, 0x0, 0x8, 0xfa, 0xf, 0xf5, + 0x0, 0x0, 0x0, 0x7f, 0xa0, 0xff, 0x70, 0x0, + 0x0, 0x8, 0xfa, 0xb, 0xfb, 0x0, 0x0, 0x0, + 0xcf, 0xa0, 0x5f, 0xf3, 0x0, 0x0, 0x4f, 0xfa, + 0x0, 0xcf, 0xe4, 0x0, 0x5e, 0xff, 0xa0, 0x1, + 0xdf, 0xff, 0xff, 0xea, 0xfa, 0x0, 0x0, 0x8d, + 0xfe, 0xa2, 0x7f, 0xa0, + + /* U+0065 "e" */ + 0x0, 0x6, 0xce, 0xfe, 0xa3, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xff, 0xf7, 0x0, 0xb, 0xfe, 0x50, + 0x1, 0x8f, 0xf5, 0x4, 0xff, 0x20, 0x0, 0x0, + 0x8f, 0xd0, 0xaf, 0xa0, 0x0, 0x0, 0x2, 0xff, + 0x3d, 0xff, 0xee, 0xee, 0xee, 0xef, 0xf5, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x6f, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0x90, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xfe, 0x0, 0x0, 0x0, 0x3e, + 0xc2, 0x5f, 0xf7, 0x0, 0x0, 0xb, 0xfe, 0x0, + 0xcf, 0xf7, 0x0, 0x19, 0xff, 0x50, 0x1, 0xcf, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x6c, 0xef, + 0xeb, 0x40, 0x0, + + /* U+0066 "f" */ + 0x0, 0x5, 0xcf, 0xfd, 0x0, 0x5, 0xff, 0xff, + 0xe0, 0x0, 0xaf, 0xe4, 0x22, 0x0, 0xc, 0xf8, + 0x0, 0x0, 0x0, 0xcf, 0x80, 0x0, 0xc, 0xff, + 0xff, 0xff, 0x20, 0xad, 0xff, 0xed, 0xd1, 0x0, + 0xc, 0xf8, 0x0, 0x0, 0x0, 0xcf, 0x80, 0x0, + 0x0, 0xc, 0xf8, 0x0, 0x0, 0x0, 0xcf, 0x80, + 0x0, 0x0, 0xc, 0xf8, 0x0, 0x0, 0x0, 0xcf, + 0x80, 0x0, 0x0, 0xc, 0xf8, 0x0, 0x0, 0x0, + 0xcf, 0x80, 0x0, 0x0, 0xc, 0xf8, 0x0, 0x0, + 0x0, 0xcf, 0x80, 0x0, 0x0, 0xc, 0xf8, 0x0, + 0x0, 0x0, 0xcf, 0x80, 0x0, 0x0, + + /* U+0067 "g" */ + 0x0, 0x1, 0x8d, 0xfe, 0xa2, 0x5f, 0xc0, 0x2, + 0xef, 0xff, 0xff, 0xf9, 0xfc, 0x0, 0xdf, 0xd3, + 0x0, 0x5e, 0xff, 0xc0, 0x6f, 0xf2, 0x0, 0x0, + 0x4f, 0xfc, 0xc, 0xfa, 0x0, 0x0, 0x0, 0xcf, + 0xc0, 0xff, 0x60, 0x0, 0x0, 0x8, 0xfc, 0x1f, + 0xf4, 0x0, 0x0, 0x0, 0x6f, 0xc1, 0xff, 0x40, + 0x0, 0x0, 0x6, 0xfc, 0xf, 0xf5, 0x0, 0x0, + 0x0, 0x7f, 0xc0, 0xcf, 0x90, 0x0, 0x0, 0xb, + 0xfc, 0x6, 0xff, 0x10, 0x0, 0x3, 0xff, 0xc0, + 0xd, 0xfd, 0x40, 0x5, 0xef, 0xfc, 0x0, 0x2e, + 0xff, 0xff, 0xff, 0xbf, 0xb0, 0x0, 0x18, 0xdf, + 0xea, 0x29, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0x90, 0x9e, 0x80, 0x0, 0x0, 0xe, 0xf5, + 0x5, 0xff, 0x60, 0x0, 0x3c, 0xfd, 0x0, 0xb, + 0xff, 0xff, 0xff, 0xfd, 0x20, 0x0, 0x6, 0xbe, + 0xfe, 0xc7, 0x10, 0x0, + + /* U+0068 "h" */ + 0x4f, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf0, + 0x4b, 0xff, 0xd7, 0x0, 0x4f, 0xf9, 0xff, 0xff, + 0xff, 0xb0, 0x4f, 0xff, 0xb3, 0x2, 0xaf, 0xf4, + 0x4f, 0xfb, 0x0, 0x0, 0xe, 0xf9, 0x4f, 0xf4, + 0x0, 0x0, 0xa, 0xfa, 0x4f, 0xf1, 0x0, 0x0, + 0x8, 0xfb, 0x4f, 0xf0, 0x0, 0x0, 0x8, 0xfb, + 0x4f, 0xf0, 0x0, 0x0, 0x8, 0xfb, 0x4f, 0xf0, + 0x0, 0x0, 0x8, 0xfb, 0x4f, 0xf0, 0x0, 0x0, + 0x8, 0xfb, 0x4f, 0xf0, 0x0, 0x0, 0x8, 0xfb, + 0x4f, 0xf0, 0x0, 0x0, 0x8, 0xfb, 0x4f, 0xf0, + 0x0, 0x0, 0x8, 0xfb, 0x4f, 0xf0, 0x0, 0x0, + 0x8, 0xfb, + + /* U+0069 "i" */ + 0x4f, 0xf0, 0x4f, 0xf0, 0x2a, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, + 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, + 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, + 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, + + /* U+006A "j" */ + 0x0, 0x4, 0xff, 0x0, 0x0, 0x4f, 0xf0, 0x0, + 0x2, 0xbb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xf0, 0x0, 0x4, 0xff, + 0x0, 0x0, 0x4f, 0xf0, 0x0, 0x4, 0xff, 0x0, + 0x0, 0x4f, 0xf0, 0x0, 0x4, 0xff, 0x0, 0x0, + 0x4f, 0xf0, 0x0, 0x4, 0xff, 0x0, 0x0, 0x4f, + 0xf0, 0x0, 0x4, 0xff, 0x0, 0x0, 0x4f, 0xf0, + 0x0, 0x4, 0xff, 0x0, 0x0, 0x4f, 0xf0, 0x0, + 0x4, 0xff, 0x0, 0x0, 0x4f, 0xf0, 0x0, 0x5, + 0xff, 0x0, 0x11, 0xaf, 0xc0, 0xe, 0xff, 0xf7, + 0x0, 0xdf, 0xe8, 0x0, + + /* U+006B "k" */ + 0x4f, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf0, + 0x0, 0x2, 0xef, 0xc1, 0x4f, 0xf0, 0x0, 0x1e, + 0xfc, 0x10, 0x4f, 0xf0, 0x1, 0xdf, 0xd1, 0x0, + 0x4f, 0xf0, 0x1d, 0xfd, 0x10, 0x0, 0x4f, 0xf1, + 0xcf, 0xd1, 0x0, 0x0, 0x4f, 0xfc, 0xff, 0x70, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x4f, 0xfd, 0x2e, 0xfb, 0x0, 0x0, 0x4f, 0xf1, + 0x5, 0xff, 0x50, 0x0, 0x4f, 0xf0, 0x0, 0xbf, + 0xe1, 0x0, 0x4f, 0xf0, 0x0, 0x2f, 0xfa, 0x0, + 0x4f, 0xf0, 0x0, 0x7, 0xff, 0x40, 0x4f, 0xf0, + 0x0, 0x0, 0xdf, 0xe0, 0x4f, 0xf0, 0x0, 0x0, + 0x3f, 0xf9, + + /* U+006C "l" */ + 0x4f, 0xf4, 0xff, 0x4f, 0xf4, 0xff, 0x4f, 0xf4, + 0xff, 0x4f, 0xf4, 0xff, 0x4f, 0xf4, 0xff, 0x4f, + 0xf4, 0xff, 0x4f, 0xf4, 0xff, 0x4f, 0xf4, 0xff, + 0x4f, 0xf4, 0xff, 0x4f, 0xf0, + + /* U+006D "m" */ + 0x4f, 0xc0, 0x6c, 0xfe, 0xb3, 0x0, 0x6c, 0xff, + 0xb3, 0x4, 0xfc, 0xaf, 0xff, 0xff, 0xf2, 0x9f, + 0xff, 0xff, 0xf2, 0x4f, 0xff, 0x92, 0x5, 0xff, + 0xef, 0x92, 0x5, 0xff, 0xa4, 0xff, 0x90, 0x0, + 0x8, 0xff, 0x90, 0x0, 0x8, 0xfe, 0x4f, 0xf3, + 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x5f, 0xf4, + 0xff, 0x0, 0x0, 0x4, 0xff, 0x0, 0x0, 0x4, + 0xff, 0x4f, 0xf0, 0x0, 0x0, 0x4f, 0xf0, 0x0, + 0x0, 0x4f, 0xf4, 0xff, 0x0, 0x0, 0x4, 0xff, + 0x0, 0x0, 0x4, 0xff, 0x4f, 0xf0, 0x0, 0x0, + 0x4f, 0xf0, 0x0, 0x0, 0x4f, 0xf4, 0xff, 0x0, + 0x0, 0x4, 0xff, 0x0, 0x0, 0x4, 0xff, 0x4f, + 0xf0, 0x0, 0x0, 0x4f, 0xf0, 0x0, 0x0, 0x4f, + 0xf4, 0xff, 0x0, 0x0, 0x4, 0xff, 0x0, 0x0, + 0x4, 0xff, 0x4f, 0xf0, 0x0, 0x0, 0x4f, 0xf0, + 0x0, 0x0, 0x4f, 0xf4, 0xff, 0x0, 0x0, 0x4, + 0xff, 0x0, 0x0, 0x4, 0xff, + + /* U+006E "n" */ + 0x3f, 0xd0, 0x5b, 0xef, 0xd7, 0x0, 0x3f, 0xd8, + 0xff, 0xff, 0xff, 0xb0, 0x3f, 0xff, 0xb3, 0x2, + 0xbf, 0xf5, 0x3f, 0xfb, 0x0, 0x0, 0xe, 0xf8, + 0x3f, 0xf4, 0x0, 0x0, 0xa, 0xfa, 0x3f, 0xf1, + 0x0, 0x0, 0x9, 0xfb, 0x3f, 0xf0, 0x0, 0x0, + 0x9, 0xfb, 0x3f, 0xf0, 0x0, 0x0, 0x9, 0xfb, + 0x3f, 0xf0, 0x0, 0x0, 0x9, 0xfb, 0x3f, 0xf0, + 0x0, 0x0, 0x9, 0xfb, 0x3f, 0xf0, 0x0, 0x0, + 0x9, 0xfb, 0x3f, 0xf0, 0x0, 0x0, 0x9, 0xfb, + 0x3f, 0xf0, 0x0, 0x0, 0x9, 0xfb, 0x3f, 0xf0, + 0x0, 0x0, 0x9, 0xfb, + + /* U+006F "o" */ + 0x0, 0x0, 0x6c, 0xef, 0xe9, 0x20, 0x0, 0x0, + 0x2d, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0xdf, + 0xe5, 0x0, 0x2b, 0xff, 0x40, 0x7, 0xff, 0x30, + 0x0, 0x0, 0xbf, 0xd0, 0xc, 0xfa, 0x0, 0x0, + 0x0, 0x3f, 0xf3, 0xf, 0xf6, 0x0, 0x0, 0x0, + 0xe, 0xf7, 0xf, 0xf4, 0x0, 0x0, 0x0, 0xd, + 0xf8, 0xf, 0xf4, 0x0, 0x0, 0x0, 0xd, 0xf7, + 0xf, 0xf6, 0x0, 0x0, 0x0, 0xe, 0xf6, 0xc, + 0xfa, 0x0, 0x0, 0x0, 0x3f, 0xf3, 0x6, 0xff, + 0x30, 0x0, 0x0, 0xbf, 0xd0, 0x0, 0xdf, 0xe5, + 0x0, 0x2a, 0xff, 0x50, 0x0, 0x2d, 0xff, 0xfe, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x6c, 0xff, 0xea, + 0x20, 0x0, + + /* U+0070 "p" */ + 0x3f, 0xd0, 0x6d, 0xfe, 0xb4, 0x0, 0x3, 0xfd, + 0xaf, 0xfd, 0xff, 0xf8, 0x0, 0x3f, 0xff, 0x90, + 0x0, 0x8f, 0xf5, 0x3, 0xff, 0xb0, 0x0, 0x0, + 0xaf, 0xd0, 0x3f, 0xf4, 0x0, 0x0, 0x3, 0xff, + 0x23, 0xff, 0x0, 0x0, 0x0, 0xf, 0xf5, 0x3f, + 0xd0, 0x0, 0x0, 0x0, 0xef, 0x73, 0xfe, 0x0, + 0x0, 0x0, 0xe, 0xf6, 0x3f, 0xf0, 0x0, 0x0, + 0x0, 0xff, 0x53, 0xff, 0x30, 0x0, 0x0, 0x4f, + 0xf1, 0x3f, 0xfa, 0x0, 0x0, 0xb, 0xfb, 0x3, + 0xff, 0xf8, 0x0, 0x1a, 0xff, 0x30, 0x3f, 0xfb, + 0xff, 0xef, 0xff, 0x50, 0x3, 0xff, 0x17, 0xdf, + 0xea, 0x20, 0x0, 0x3f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0071 "q" */ + 0x0, 0x1, 0x8d, 0xfe, 0x91, 0x6f, 0xa0, 0x2, + 0xef, 0xfd, 0xef, 0xe8, 0xfa, 0x0, 0xdf, 0xd2, + 0x0, 0x4e, 0xff, 0xa0, 0x6f, 0xf1, 0x0, 0x0, + 0x5f, 0xfa, 0xb, 0xfa, 0x0, 0x0, 0x0, 0xef, + 0xa0, 0xef, 0x60, 0x0, 0x0, 0x9, 0xfa, 0xf, + 0xf5, 0x0, 0x0, 0x0, 0x7f, 0xa0, 0xff, 0x50, + 0x0, 0x0, 0x6, 0xfa, 0xe, 0xf7, 0x0, 0x0, + 0x0, 0x8f, 0xa0, 0xaf, 0xb0, 0x0, 0x0, 0xb, + 0xfa, 0x4, 0xff, 0x30, 0x0, 0x3, 0xff, 0xa0, + 0xb, 0xfe, 0x40, 0x4, 0xef, 0xfa, 0x0, 0x1c, + 0xff, 0xff, 0xfe, 0xcf, 0xa0, 0x0, 0x7, 0xdf, + 0xea, 0x1a, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xa0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xa0, + + /* U+0072 "r" */ + 0x5f, 0xc0, 0xaf, 0xea, 0x5, 0xfc, 0xbf, 0xff, + 0xb0, 0x5f, 0xff, 0xa6, 0x95, 0x5, 0xff, 0xa0, + 0x0, 0x0, 0x5f, 0xf3, 0x0, 0x0, 0x5, 0xff, + 0x0, 0x0, 0x0, 0x5f, 0xf0, 0x0, 0x0, 0x5, + 0xff, 0x0, 0x0, 0x0, 0x5f, 0xf0, 0x0, 0x0, + 0x5, 0xff, 0x0, 0x0, 0x0, 0x5f, 0xf0, 0x0, + 0x0, 0x5, 0xff, 0x0, 0x0, 0x0, 0x5f, 0xf0, + 0x0, 0x0, 0x5, 0xff, 0x0, 0x0, 0x0, + + /* U+0073 "s" */ + 0x0, 0x7, 0xdf, 0xfd, 0xa3, 0x0, 0x1, 0xdf, + 0xff, 0xff, 0xff, 0x70, 0x8, 0xfe, 0x30, 0x1, + 0xaf, 0xf2, 0xc, 0xf7, 0x0, 0x0, 0xe, 0xe5, + 0xb, 0xfc, 0x10, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xfb, 0x62, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xd8, 0x10, 0x0, 0x1, 0x6b, 0xff, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x3, 0x8f, 0xfb, 0x6, 0x91, + 0x0, 0x0, 0x7, 0xff, 0xf, 0xf7, 0x0, 0x0, + 0x7, 0xfe, 0x9, 0xff, 0x60, 0x0, 0x5f, 0xf8, + 0x0, 0xcf, 0xff, 0xef, 0xff, 0xc0, 0x0, 0x6, + 0xce, 0xfe, 0xc6, 0x0, + + /* U+0074 "t" */ + 0x0, 0x4, 0x30, 0x0, 0x9, 0xf6, 0x0, 0x0, + 0xef, 0x60, 0x0, 0xe, 0xf6, 0x0, 0x0, 0xef, + 0x60, 0x9, 0xff, 0xff, 0xfa, 0x7d, 0xff, 0xed, + 0x80, 0xe, 0xf6, 0x0, 0x0, 0xef, 0x60, 0x0, + 0xe, 0xf6, 0x0, 0x0, 0xef, 0x60, 0x0, 0xe, + 0xf6, 0x0, 0x0, 0xef, 0x60, 0x0, 0xe, 0xf6, + 0x0, 0x0, 0xef, 0x60, 0x0, 0xe, 0xf6, 0x0, + 0x0, 0xdf, 0xb3, 0x20, 0x9, 0xff, 0xfc, 0x0, + 0xa, 0xef, 0xc0, + + /* U+0075 "u" */ + 0x4f, 0xf0, 0x0, 0x0, 0xa, 0xfa, 0x4f, 0xf0, + 0x0, 0x0, 0xa, 0xfa, 0x4f, 0xf0, 0x0, 0x0, + 0xa, 0xfa, 0x4f, 0xf0, 0x0, 0x0, 0xa, 0xfa, + 0x4f, 0xf0, 0x0, 0x0, 0xa, 0xfa, 0x4f, 0xf0, + 0x0, 0x0, 0xa, 0xfa, 0x4f, 0xf0, 0x0, 0x0, + 0xa, 0xfa, 0x4f, 0xf0, 0x0, 0x0, 0xa, 0xfa, + 0x4f, 0xf0, 0x0, 0x0, 0xb, 0xfa, 0x3f, 0xf1, + 0x0, 0x0, 0xe, 0xfa, 0x1f, 0xf4, 0x0, 0x0, + 0x5f, 0xfa, 0xd, 0xfe, 0x40, 0x16, 0xff, 0xfa, + 0x4, 0xff, 0xff, 0xff, 0xd7, 0xfa, 0x0, 0x3a, + 0xef, 0xd7, 0x6, 0xfa, + + /* U+0076 "v" */ + 0x7f, 0xe0, 0x0, 0x0, 0x0, 0xdf, 0x82, 0xff, + 0x40, 0x0, 0x0, 0x3f, 0xf2, 0xc, 0xf9, 0x0, + 0x0, 0x8, 0xfc, 0x0, 0x6f, 0xe0, 0x0, 0x0, + 0xef, 0x60, 0x0, 0xff, 0x40, 0x0, 0x3f, 0xf1, + 0x0, 0xa, 0xfa, 0x0, 0x9, 0xfb, 0x0, 0x0, + 0x4f, 0xf0, 0x0, 0xef, 0x50, 0x0, 0x0, 0xef, + 0x50, 0x4f, 0xe0, 0x0, 0x0, 0x9, 0xfa, 0xa, + 0xf9, 0x0, 0x0, 0x0, 0x3f, 0xf0, 0xff, 0x30, + 0x0, 0x0, 0x0, 0xdf, 0x9f, 0xd0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xc0, 0x0, 0x0, + + /* U+0077 "w" */ + 0xbf, 0x90, 0x0, 0x0, 0xdf, 0xb0, 0x0, 0x0, + 0xbf, 0x76, 0xfe, 0x0, 0x0, 0x1f, 0xff, 0x0, + 0x0, 0xf, 0xf2, 0x2f, 0xf2, 0x0, 0x6, 0xff, + 0xf3, 0x0, 0x4, 0xfd, 0x0, 0xdf, 0x60, 0x0, + 0xaf, 0xdf, 0x70, 0x0, 0x9f, 0x90, 0x8, 0xfa, + 0x0, 0xe, 0xf6, 0xfb, 0x0, 0xe, 0xf4, 0x0, + 0x4f, 0xf0, 0x2, 0xfc, 0x2f, 0xf0, 0x2, 0xff, + 0x0, 0x0, 0xff, 0x30, 0x6f, 0x80, 0xef, 0x30, + 0x7f, 0xa0, 0x0, 0xa, 0xf7, 0xb, 0xf4, 0xa, + 0xf7, 0xb, 0xf5, 0x0, 0x0, 0x5f, 0xc0, 0xef, + 0x0, 0x5f, 0xb0, 0xff, 0x10, 0x0, 0x1, 0xff, + 0x3f, 0xc0, 0x1, 0xff, 0x5f, 0xc0, 0x0, 0x0, + 0xc, 0xfb, 0xf8, 0x0, 0xd, 0xfd, 0xf7, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x40, 0x0, 0x9f, 0xff, + 0x20, 0x0, 0x0, 0x3, 0xff, 0xf0, 0x0, 0x5, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0xe, 0xfc, 0x0, + 0x0, 0x1f, 0xf8, 0x0, 0x0, + + /* U+0078 "x" */ + 0x2f, 0xfb, 0x0, 0x0, 0xa, 0xff, 0x20, 0x6f, + 0xf5, 0x0, 0x4, 0xff, 0x60, 0x0, 0xbf, 0xe1, + 0x1, 0xef, 0xa0, 0x0, 0x1, 0xff, 0x90, 0xaf, + 0xe1, 0x0, 0x0, 0x6, 0xff, 0x8f, 0xf4, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x2, 0xff, 0xdf, + 0xf2, 0x0, 0x0, 0x0, 0xcf, 0xd0, 0xdf, 0xc0, + 0x0, 0x0, 0x7f, 0xf3, 0x3, 0xff, 0x70, 0x0, + 0x2f, 0xf8, 0x0, 0x9, 0xff, 0x20, 0xc, 0xfd, + 0x0, 0x0, 0xe, 0xfc, 0x7, 0xff, 0x40, 0x0, + 0x0, 0x5f, 0xf7, + + /* U+0079 "y" */ + 0x6f, 0xf1, 0x0, 0x0, 0x0, 0xbf, 0x90, 0xff, + 0x60, 0x0, 0x0, 0x1f, 0xf3, 0xa, 0xfc, 0x0, + 0x0, 0x6, 0xfd, 0x0, 0x4f, 0xf2, 0x0, 0x0, + 0xcf, 0x70, 0x0, 0xdf, 0x70, 0x0, 0x2f, 0xf1, + 0x0, 0x8, 0xfd, 0x0, 0x8, 0xfb, 0x0, 0x0, + 0x2f, 0xf3, 0x0, 0xef, 0x50, 0x0, 0x0, 0xbf, + 0x90, 0x4f, 0xe0, 0x0, 0x0, 0x5, 0xfe, 0x9, + 0xf9, 0x0, 0x0, 0x0, 0xf, 0xf3, 0xef, 0x30, + 0x0, 0x0, 0x0, 0x9f, 0xbf, 0xd0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xfe, 0x0, 0x0, 0x0, + 0x4, 0x46, 0xef, 0x70, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x5, 0xef, 0xb1, + 0x0, 0x0, 0x0, 0x0, + + /* U+007A "z" */ + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0xdd, + 0xdd, 0xdd, 0xdd, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xfe, 0x10, 0x0, 0x0, 0x0, 0xa, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x7, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x4, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xef, 0xff, 0xff, 0xff, 0x77, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf7, + + /* U+007B "{" */ + 0x0, 0x0, 0x3b, 0xef, 0x10, 0x0, 0x1f, 0xff, + 0xf1, 0x0, 0x6, 0xfe, 0x30, 0x0, 0x0, 0x8f, + 0x90, 0x0, 0x0, 0x9, 0xf8, 0x0, 0x0, 0x0, + 0xaf, 0x80, 0x0, 0x0, 0xa, 0xf7, 0x0, 0x0, + 0x0, 0xbf, 0x70, 0x0, 0x0, 0xc, 0xf5, 0x0, + 0x0, 0x1, 0xff, 0x20, 0x0, 0x4, 0xcf, 0xa0, + 0x0, 0x4, 0xff, 0x80, 0x0, 0x0, 0x4f, 0xfb, + 0x10, 0x0, 0x0, 0x1a, 0xfb, 0x0, 0x0, 0x0, + 0xf, 0xf2, 0x0, 0x0, 0x0, 0xcf, 0x60, 0x0, + 0x0, 0xb, 0xf7, 0x0, 0x0, 0x0, 0xaf, 0x80, + 0x0, 0x0, 0xa, 0xf8, 0x0, 0x0, 0x0, 0x9f, + 0x80, 0x0, 0x0, 0x8, 0xf9, 0x0, 0x0, 0x0, + 0x6f, 0xe3, 0x0, 0x0, 0x1, 0xef, 0xff, 0x10, + 0x0, 0x2, 0xcf, 0xf1, + + /* U+007C "|" */ + 0x9f, 0x69, 0xf6, 0x9f, 0x69, 0xf6, 0x9f, 0x69, + 0xf6, 0x9f, 0x69, 0xf6, 0x9f, 0x69, 0xf6, 0x9f, + 0x69, 0xf6, 0x9f, 0x69, 0xf6, 0x9f, 0x69, 0xf6, + 0x9f, 0x69, 0xf6, 0x9f, 0x69, 0xf6, 0x9f, 0x69, + 0xf6, 0x9f, 0x69, 0xf6, + + /* U+007D "}" */ + 0x6f, 0xe9, 0x0, 0x0, 0x6f, 0xff, 0xa0, 0x0, + 0x1, 0x6f, 0xf1, 0x0, 0x0, 0xe, 0xf3, 0x0, + 0x0, 0xd, 0xf4, 0x0, 0x0, 0xd, 0xf4, 0x0, + 0x0, 0xd, 0xf5, 0x0, 0x0, 0xc, 0xf5, 0x0, + 0x0, 0xa, 0xf7, 0x0, 0x0, 0x7, 0xfb, 0x0, + 0x0, 0x1, 0xef, 0x93, 0x0, 0x0, 0x2c, 0xff, + 0x0, 0x0, 0x3d, 0xff, 0x0, 0x1, 0xff, 0x60, + 0x0, 0x8, 0xfb, 0x0, 0x0, 0xb, 0xf7, 0x0, + 0x0, 0xc, 0xf5, 0x0, 0x0, 0xc, 0xf5, 0x0, + 0x0, 0xd, 0xf4, 0x0, 0x0, 0xd, 0xf4, 0x0, + 0x0, 0xe, 0xf3, 0x0, 0x1, 0x6f, 0xf1, 0x0, + 0x6f, 0xff, 0xa0, 0x0, 0x6f, 0xe9, 0x0, 0x0, + + /* U+007E "~" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x18, + 0xdf, 0xeb, 0x60, 0x0, 0x0, 0x81, 0xcf, 0xff, + 0xff, 0xff, 0xb7, 0x8d, 0xf1, 0xee, 0x97, 0x9e, + 0xff, 0xff, 0xff, 0xf1, 0x91, 0x0, 0x0, 0x49, + 0xdf, 0xea, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+00A0 " " */ + + /* U+00A3 "£" */ + 0x0, 0x0, 0x3a, 0xef, 0xfb, 0x50, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x6f, + 0xfa, 0x10, 0x7, 0xff, 0x90, 0x0, 0xdf, 0xb0, + 0x0, 0x0, 0x8f, 0xf0, 0x0, 0xff, 0x60, 0x0, + 0x0, 0x1d, 0xb2, 0x0, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x5e, 0xff, 0xfe, 0xee, 0xe1, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0xd, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x4e, 0xfe, 0xef, 0xeb, 0x85, 0x35, 0xa2, 0x5f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xc, 0x61, + 0x0, 0x15, 0x9d, 0xfe, 0xa4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+00A4 "¤" */ + 0x1, 0x90, 0x0, 0x0, 0x0, 0x6, 0x50, 0xb, + 0xfc, 0x3a, 0xef, 0xc6, 0x6f, 0xf3, 0x3, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x6f, 0xf9, + 0x32, 0x6f, 0xfd, 0x0, 0x0, 0xbf, 0x90, 0x0, + 0x3, 0xff, 0x30, 0x0, 0xff, 0x10, 0x0, 0x0, + 0xbf, 0x70, 0x1, 0xff, 0x0, 0x0, 0x0, 0x8f, + 0x90, 0x0, 0xff, 0x10, 0x0, 0x0, 0xbf, 0x70, + 0x0, 0xbf, 0xa0, 0x0, 0x3, 0xff, 0x30, 0x0, + 0x6f, 0xfa, 0x43, 0x7f, 0xfd, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xa0, 0xb, 0xfb, 0x3a, + 0xef, 0xc6, 0x5f, 0xf3, 0x1, 0x90, 0x0, 0x0, + 0x0, 0x5, 0x50, + + /* U+00A5 "¥" */ + 0xbf, 0xd0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x22, + 0xff, 0x60, 0x0, 0x0, 0x1, 0xff, 0x90, 0x9, + 0xfe, 0x0, 0x0, 0x0, 0xaf, 0xf1, 0x0, 0x1e, + 0xf8, 0x0, 0x0, 0x2f, 0xf7, 0x0, 0x0, 0x6f, + 0xf1, 0x0, 0xb, 0xfd, 0x0, 0x0, 0x0, 0xdf, + 0x90, 0x3, 0xff, 0x50, 0x0, 0x0, 0x4, 0xff, + 0x20, 0xcf, 0xc0, 0x0, 0x0, 0x0, 0xb, 0xfb, + 0x4f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xfd, + 0xfa, 0x0, 0x0, 0x2, 0xee, 0xee, 0xff, 0xff, + 0xee, 0xee, 0x90, 0x2f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0xe, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0x60, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xa0, 0x1c, 0xcc, 0xcc, 0xff, 0xec, 0xcc, 0xc7, + 0x0, 0x0, 0x0, 0xe, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0x60, 0x0, 0x0, 0x0, + + /* U+00A6 "¦" */ + 0x9f, 0x69, 0xf6, 0x9f, 0x69, 0xf6, 0x9f, 0x69, + 0xf6, 0x9f, 0x69, 0xf6, 0x9f, 0x69, 0xf6, 0x13, + 0x10, 0x0, 0x0, 0x1, 0x31, 0x9f, 0x69, 0xf6, + 0x9f, 0x69, 0xf6, 0x9f, 0x69, 0xf6, 0x9f, 0x69, + 0xf6, 0x9f, 0x69, 0xf6, + + /* U+00A7 "§" */ + 0x0, 0x6, 0xdf, 0xfd, 0x81, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0xe1, 0x0, 0x5, 0xff, 0x60, + 0x4, 0xff, 0xa0, 0x0, 0xaf, 0xa0, 0x0, 0x7, + 0xff, 0x0, 0xa, 0xfb, 0x0, 0x0, 0x28, 0x71, + 0x0, 0x4f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xfb, 0x10, 0x0, 0x0, 0x0, 0x3b, 0xff, + 0xfe, 0x60, 0x0, 0x0, 0x3f, 0xf4, 0x4e, 0xff, + 0xc2, 0x0, 0xb, 0xf6, 0x0, 0x19, 0xff, 0xf6, + 0x0, 0xef, 0x30, 0x0, 0x4, 0xef, 0xf7, 0xc, + 0xf7, 0x0, 0x0, 0x1, 0xdf, 0xf1, 0x5f, 0xf4, + 0x0, 0x0, 0x2, 0xff, 0x30, 0x9f, 0xf9, 0x0, + 0x0, 0xe, 0xf3, 0x0, 0x6f, 0xfe, 0x50, 0x3, + 0xfd, 0x0, 0x0, 0x2b, 0xff, 0xb5, 0xec, 0x20, + 0x0, 0x0, 0x5, 0xef, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xaf, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xf2, 0x0, 0xac, 0x40, 0x0, 0x0, + 0xff, 0x60, 0xe, 0xfa, 0x0, 0x0, 0xf, 0xf6, + 0x0, 0x7f, 0xf9, 0x10, 0x2b, 0xff, 0x10, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x5b, + 0xef, 0xea, 0x30, 0x0, + + /* U+00A8 "¨" */ + 0x2a, 0xa1, 0x4, 0xa9, 0x3f, 0xf2, 0x7, 0xfe, + 0x3f, 0xf2, 0x7, 0xfe, + + /* U+00A9 "©" */ + 0x0, 0x0, 0x0, 0x15, 0x89, 0x86, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2a, 0xff, 0xff, 0xff, + 0xfc, 0x30, 0x0, 0x0, 0x0, 0x6, 0xff, 0xa4, + 0x10, 0x14, 0x9f, 0xf7, 0x0, 0x0, 0x0, 0x6f, + 0xd2, 0x0, 0x0, 0x0, 0x1, 0xcf, 0x80, 0x0, + 0x3, 0xfd, 0x10, 0x0, 0x1, 0x0, 0x0, 0xb, + 0xf5, 0x0, 0xc, 0xe2, 0x0, 0x2b, 0xff, 0xfc, + 0x30, 0x1, 0xde, 0x0, 0x4f, 0x70, 0x3, 0xff, + 0x85, 0x7d, 0xf4, 0x0, 0x4f, 0x70, 0x9f, 0x10, + 0xc, 0xf3, 0x0, 0x1, 0xed, 0x0, 0xe, 0xc0, + 0xdc, 0x0, 0x2f, 0xa0, 0x0, 0x0, 0x21, 0x0, + 0x9, 0xf0, 0xfa, 0x0, 0x5f, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xf1, 0xf9, 0x0, 0x6f, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xf1, 0xeb, 0x0, + 0x5f, 0x60, 0x0, 0x0, 0x0, 0x0, 0x8, 0xf0, + 0xbe, 0x0, 0x1f, 0xb0, 0x0, 0x0, 0x8c, 0x10, + 0xc, 0xd0, 0x6f, 0x40, 0xb, 0xf4, 0x0, 0x4, + 0xfc, 0x0, 0x1f, 0x90, 0x1f, 0xc0, 0x1, 0xef, + 0xa8, 0xbf, 0xe2, 0x0, 0xaf, 0x20, 0x7, 0xf8, + 0x0, 0x19, 0xef, 0xd9, 0x10, 0x5, 0xf9, 0x0, + 0x0, 0xbf, 0x80, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xc0, 0x0, 0x0, 0xb, 0xfc, 0x30, 0x0, 0x0, + 0x2a, 0xfc, 0x10, 0x0, 0x0, 0x0, 0x7f, 0xfe, + 0xba, 0xbd, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x7c, 0xef, 0xec, 0x82, 0x0, 0x0, 0x0, + + /* U+00AA "ª" */ + 0x0, 0x8e, 0xfc, 0x39, 0xf3, 0xa, 0xfc, 0x7c, + 0xfe, 0xf0, 0x3f, 0xd0, 0x0, 0xdf, 0xb0, 0x7f, + 0x80, 0x0, 0x7f, 0x80, 0x9f, 0x60, 0x0, 0x5f, + 0x50, 0x9f, 0x60, 0x0, 0x5f, 0x50, 0x7f, 0x80, + 0x0, 0x8f, 0x80, 0x2f, 0xd0, 0x0, 0xef, 0xb0, + 0x9, 0xfc, 0x7c, 0xfe, 0xf0, 0x0, 0x8e, 0xfc, + 0x49, 0xf3, + + /* U+00AB "«" */ + 0x0, 0x0, 0x5c, 0x50, 0x6, 0xc4, 0x0, 0x2, + 0xfe, 0x0, 0x2f, 0xd0, 0x0, 0xc, 0xf6, 0x0, + 0xcf, 0x50, 0x0, 0x7f, 0xd0, 0x8, 0xfc, 0x0, + 0x2, 0xff, 0x40, 0x3f, 0xf3, 0x0, 0xc, 0xfb, + 0x0, 0xdf, 0xa0, 0x0, 0x1e, 0xf9, 0x1, 0xef, + 0x80, 0x0, 0x4, 0xff, 0x20, 0x5f, 0xf1, 0x0, + 0x0, 0x9f, 0xb0, 0xa, 0xfa, 0x0, 0x0, 0xd, + 0xf4, 0x1, 0xef, 0x30, 0x0, 0x3, 0xfc, 0x0, + 0x4f, 0xc0, 0x0, 0x0, 0x8f, 0x60, 0xa, 0xf5, + + /* U+00AC "¬" */ + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb8, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0x12, 0x22, 0x22, + 0x22, 0x22, 0x8f, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xa7, + + /* U+00AD "­" */ + 0x5, 0x55, 0x55, 0x54, 0x2f, 0xff, 0xff, 0xfd, + 0x2f, 0xff, 0xff, 0xfd, + + /* U+00AE "®" */ + 0x0, 0x0, 0x0, 0x15, 0x89, 0x86, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2a, 0xff, 0xff, 0xff, + 0xfc, 0x30, 0x0, 0x0, 0x0, 0x6, 0xff, 0xa4, + 0x10, 0x14, 0x9f, 0xf7, 0x0, 0x0, 0x0, 0x6f, + 0xd2, 0x0, 0x0, 0x0, 0x1, 0xcf, 0x80, 0x0, + 0x3, 0xfd, 0x11, 0x11, 0x11, 0x0, 0x0, 0xb, + 0xf5, 0x0, 0xc, 0xe2, 0x9, 0xff, 0xff, 0xfc, + 0x20, 0x1, 0xde, 0x0, 0x4f, 0x70, 0x9, 0xf5, + 0x45, 0x8f, 0xe0, 0x0, 0x4f, 0x70, 0x9f, 0x10, + 0x9, 0xf0, 0x0, 0x8, 0xf4, 0x0, 0xe, 0xc0, + 0xdc, 0x0, 0x9, 0xf0, 0x0, 0x8, 0xf3, 0x0, + 0x9, 0xf0, 0xfa, 0x0, 0x9, 0xf2, 0x22, 0x6f, + 0xd0, 0x0, 0x7, 0xf1, 0xf9, 0x0, 0x9, 0xff, + 0xff, 0xfc, 0x20, 0x0, 0x7, 0xf1, 0xeb, 0x0, + 0x9, 0xf5, 0x6c, 0xd2, 0x0, 0x0, 0x8, 0xf0, + 0xbe, 0x0, 0x9, 0xf0, 0x0, 0xde, 0x10, 0x0, + 0xc, 0xd0, 0x6f, 0x40, 0x9, 0xf0, 0x0, 0x3f, + 0xa0, 0x0, 0x1f, 0x90, 0x1f, 0xc0, 0x9, 0xf0, + 0x0, 0xa, 0xf4, 0x0, 0xaf, 0x20, 0x7, 0xf8, + 0x6, 0xb0, 0x0, 0x2, 0xb9, 0x5, 0xf9, 0x0, + 0x0, 0xbf, 0x80, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xc0, 0x0, 0x0, 0xb, 0xfc, 0x30, 0x0, 0x0, + 0x2a, 0xfc, 0x10, 0x0, 0x0, 0x0, 0x7f, 0xfe, + 0xba, 0xbd, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x7c, 0xef, 0xec, 0x82, 0x0, 0x0, 0x0, + + /* U+00B0 "°" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfd, 0x30, + 0xa, 0xf7, 0x5c, 0xf1, 0x2f, 0x50, 0x0, 0xe8, + 0x4f, 0x10, 0x0, 0xbb, 0x3f, 0x40, 0x0, 0xd9, + 0xc, 0xe4, 0x2a, 0xf3, 0x1, 0xcf, 0xff, 0x60, + 0x0, 0x3, 0x41, 0x0, + + /* U+00B1 "±" */ + 0x0, 0x0, 0x7, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xfa, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xb1, 0x22, 0x22, + 0x9f, 0xb2, 0x22, 0x21, 0x0, 0x0, 0x7, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0x75, 0x0, 0x0, 0x1, 0x22, 0x22, 0x22, + 0x22, 0x22, 0x22, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xb8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, + + /* U+00B2 "²" */ + 0x1, 0x9e, 0xfd, 0x91, 0x0, 0xcf, 0xb8, 0xcf, + 0xc0, 0x3e, 0xb0, 0x0, 0xef, 0x10, 0x0, 0x0, + 0xe, 0xf0, 0x0, 0x0, 0xb, 0xf9, 0x0, 0x0, + 0x2c, 0xfc, 0x0, 0x0, 0x3e, 0xf9, 0x0, 0x0, + 0x4f, 0xf6, 0x0, 0x0, 0x1f, 0xfc, 0x88, 0x88, + 0x18, 0xff, 0xff, 0xff, 0xf3, + + /* U+00B3 "³" */ + 0x2, 0xbe, 0xfd, 0x80, 0x0, 0xdf, 0x97, 0xdf, + 0x80, 0x19, 0x70, 0x4, 0xfb, 0x0, 0x0, 0x2, + 0xbf, 0x60, 0x0, 0x5, 0xff, 0x90, 0x0, 0x0, + 0x25, 0x9f, 0xa0, 0x0, 0x0, 0x0, 0xdf, 0x25, + 0xe7, 0x0, 0x1f, 0xf2, 0x1e, 0xfa, 0x8d, 0xfb, + 0x0, 0x2a, 0xef, 0xd7, 0x0, + + /* U+00B5 "µ" */ + 0x3f, 0xf0, 0x0, 0x0, 0x9, 0xfa, 0x3f, 0xf0, + 0x0, 0x0, 0x9, 0xfa, 0x3f, 0xf0, 0x0, 0x0, + 0x9, 0xfa, 0x3f, 0xf0, 0x0, 0x0, 0x9, 0xfa, + 0x3f, 0xf0, 0x0, 0x0, 0x9, 0xfa, 0x3f, 0xf0, + 0x0, 0x0, 0x9, 0xfa, 0x3f, 0xf0, 0x0, 0x0, + 0x9, 0xfa, 0x3f, 0xf0, 0x0, 0x0, 0x9, 0xfa, + 0x3f, 0xf1, 0x0, 0x0, 0xa, 0xfa, 0x3f, 0xf4, + 0x0, 0x0, 0xd, 0xfa, 0x3f, 0xfb, 0x0, 0x0, + 0x4f, 0xfa, 0x3f, 0xff, 0xa3, 0x27, 0xff, 0xfa, + 0x3f, 0xfd, 0xff, 0xff, 0xfa, 0xfa, 0x3f, 0xf1, + 0x9e, 0xfc, 0x46, 0xfa, 0x3f, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf0, 0x0, 0x0, + 0x0, 0x0, + + /* U+00B6 "¶" */ + 0x0, 0x3, 0xae, 0xff, 0xff, 0xff, 0xff, 0xf0, + 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x4, + 0xff, 0xff, 0xff, 0x53, 0x3f, 0xf5, 0x30, 0xbf, + 0xff, 0xff, 0xf2, 0x0, 0xff, 0x20, 0xf, 0xff, + 0xff, 0xff, 0x20, 0xf, 0xf2, 0x0, 0xff, 0xff, + 0xff, 0xf2, 0x0, 0xff, 0x20, 0xe, 0xff, 0xff, + 0xff, 0x20, 0xf, 0xf2, 0x0, 0xaf, 0xff, 0xff, + 0xf2, 0x0, 0xff, 0x20, 0x2, 0xff, 0xff, 0xff, + 0x20, 0xf, 0xf2, 0x0, 0x4, 0xef, 0xff, 0xf2, + 0x0, 0xff, 0x20, 0x0, 0x0, 0x58, 0xff, 0x20, + 0xf, 0xf2, 0x0, 0x0, 0x0, 0xe, 0xf2, 0x0, + 0xff, 0x20, 0x0, 0x0, 0x0, 0xef, 0x20, 0xf, + 0xf2, 0x0, 0x0, 0x0, 0xe, 0xf2, 0x0, 0xff, + 0x20, 0x0, 0x0, 0x0, 0xef, 0x20, 0xf, 0xf2, + 0x0, 0x0, 0x0, 0xe, 0xf2, 0x0, 0xff, 0x20, + 0x0, 0x0, 0x0, 0xef, 0x20, 0xf, 0xf2, 0x0, + 0x0, 0x0, 0xe, 0xf2, 0x0, 0xff, 0x20, 0x0, + 0x0, 0x0, 0xef, 0x20, 0xf, 0xf2, 0x0, 0x0, + 0x0, 0xe, 0xf2, 0x0, 0xff, 0x20, 0x0, 0x0, + 0x0, 0xef, 0x20, 0xf, 0xf2, 0x0, 0x0, 0x0, + 0xe, 0xf2, 0x0, 0xff, 0x20, 0x0, 0x0, 0x0, + 0xef, 0x20, 0xf, 0xf2, 0x0, 0x0, 0x0, 0xe, + 0xf2, 0x0, 0xff, 0x20, + + /* U+00B7 "·" */ + 0x6a, 0x9a, 0xff, 0xaf, 0xf0, + + /* U+00BB "»" */ + 0xb, 0xb0, 0x0, 0xba, 0x0, 0x0, 0x7, 0xf9, + 0x0, 0x8f, 0x80, 0x0, 0x0, 0xdf, 0x40, 0xe, + 0xf3, 0x0, 0x0, 0x4f, 0xe1, 0x6, 0xfd, 0x0, + 0x0, 0xb, 0xfa, 0x0, 0xcf, 0x90, 0x0, 0x2, + 0xff, 0x40, 0x4f, 0xf4, 0x0, 0x1, 0xff, 0x70, + 0x2f, 0xf6, 0x0, 0x9, 0xfc, 0x0, 0xaf, 0xb0, + 0x0, 0x2f, 0xf2, 0x3, 0xff, 0x10, 0x0, 0xbf, + 0x70, 0xc, 0xf6, 0x0, 0x5, 0xfc, 0x0, 0x5f, + 0xb0, 0x0, 0xd, 0xf2, 0x0, 0xee, 0x10, 0x0, + + /* U+00BD "½" */ + 0x0, 0x8, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xc7, 0x0, 0x0, 0x9, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xee, 0x10, 0x0, 0x4d, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0x40, 0x0, 0xa, + 0xd4, 0xcf, 0x0, 0x0, 0x0, 0x0, 0x6f, 0x90, + 0x0, 0x0, 0x10, 0xc, 0xf0, 0x0, 0x0, 0x0, + 0x2f, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0x0, + 0x0, 0x0, 0xc, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xf0, 0x0, 0x0, 0x7, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0x0, 0x0, 0x2, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xf0, 0x0, + 0x0, 0xcf, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0x0, 0x0, 0x8f, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xc0, 0x0, + 0x26, 0x86, 0x20, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xf2, 0x0, 0x7f, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x9, 0xf6, 0x0, 0x2f, 0xe3, 0x4, 0xff, + 0x0, 0x0, 0x0, 0x4, 0xfb, 0x0, 0x1, 0x53, + 0x0, 0xd, 0xf1, 0x0, 0x0, 0x1, 0xee, 0x10, + 0x0, 0x0, 0x0, 0x6, 0xfb, 0x0, 0x0, 0x0, + 0xaf, 0x50, 0x0, 0x0, 0x0, 0x9, 0xfd, 0x10, + 0x0, 0x0, 0x5f, 0xa0, 0x0, 0x0, 0x0, 0x1c, + 0xfb, 0x10, 0x0, 0x0, 0x1e, 0xe1, 0x0, 0x0, + 0x0, 0x2e, 0xf7, 0x0, 0x0, 0x0, 0xb, 0xf4, + 0x0, 0x0, 0x0, 0x1e, 0xfc, 0x99, 0x99, 0x20, + 0x6, 0xf9, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x77, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0384 "΄" */ + 0x0, 0x69, 0x92, 0x1, 0xff, 0xa0, 0x7, 0xfd, + 0x0, 0xe, 0xf2, 0x0, + + /* U+0386 "Ά" */ + 0x0, 0xd, 0xfe, 0x11, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0x30, 0x6f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0x60, 0xc, 0xfb, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x19, 0x70, 0x2, + 0xff, 0x2f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xb0, 0xcf, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xf6, 0x6, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0x10, 0x1f, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xa0, 0x0, + 0xaf, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf4, + 0x0, 0x4, 0xff, 0x30, 0x0, 0x0, 0x0, 0x7, + 0xfe, 0x0, 0x0, 0xe, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0x80, 0x0, 0x0, 0x8f, 0xf0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0xef, 0x80, 0x0, + 0x0, 0x0, 0x6f, 0xf3, 0x0, 0x0, 0x5f, 0xf2, + 0x0, 0x0, 0x0, 0x1, 0xff, 0x90, 0x0, 0xb, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0x0, + 0x1, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xf6, 0x0, 0x7f, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xc0, 0xd, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0x30, + + /* U+0388 "Έ" */ + 0x0, 0xaf, 0xf3, 0xe, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x80, 0x2f, 0xf6, 0x0, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf8, 0x9, 0xf9, 0x0, + 0xe, 0xfa, 0x33, 0x33, 0x33, 0x33, 0x33, 0x20, + 0x99, 0x0, 0x0, 0xef, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0xe, 0xfa, 0x33, 0x33, + 0x33, 0x33, 0x32, 0x0, 0x0, 0x0, 0x0, 0xef, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xfa, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x30, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, + + /* U+0389 "Ή" */ + 0x0, 0xaf, 0xf3, 0x6f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xf2, 0x2, 0xff, 0x60, 0x6f, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf2, 0x9, 0xfa, + 0x0, 0x6f, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xf2, 0x9, 0x90, 0x0, 0x6f, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xf2, 0x0, 0x0, 0x0, 0x6f, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf2, 0x0, + 0x0, 0x0, 0x6f, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xf2, 0x0, 0x0, 0x0, 0x6f, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xf2, 0x0, 0x0, 0x0, + 0x6f, 0xf4, 0x33, 0x33, 0x33, 0x33, 0x7f, 0xf2, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x6f, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xf2, 0x0, 0x0, 0x0, 0x6f, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xf2, 0x0, 0x0, 0x0, 0x6f, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf2, 0x0, + 0x0, 0x0, 0x6f, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xf2, 0x0, 0x0, 0x0, 0x6f, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xf2, 0x0, 0x0, 0x0, + 0x6f, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf2, + 0x0, 0x0, 0x0, 0x6f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xf2, 0x0, 0x0, 0x0, 0x6f, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf2, 0x0, 0x0, + 0x0, 0x6f, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xf2, + + /* U+038A "Ί" */ + 0x0, 0xaf, 0xf3, 0x6f, 0xf0, 0x2, 0xff, 0x60, + 0x6f, 0xf0, 0x9, 0xfa, 0x0, 0x6f, 0xf0, 0x9, + 0x90, 0x0, 0x6f, 0xf0, 0x0, 0x0, 0x0, 0x6f, + 0xf0, 0x0, 0x0, 0x0, 0x6f, 0xf0, 0x0, 0x0, + 0x0, 0x6f, 0xf0, 0x0, 0x0, 0x0, 0x6f, 0xf0, + 0x0, 0x0, 0x0, 0x6f, 0xf0, 0x0, 0x0, 0x0, + 0x6f, 0xf0, 0x0, 0x0, 0x0, 0x6f, 0xf0, 0x0, + 0x0, 0x0, 0x6f, 0xf0, 0x0, 0x0, 0x0, 0x6f, + 0xf0, 0x0, 0x0, 0x0, 0x6f, 0xf0, 0x0, 0x0, + 0x0, 0x6f, 0xf0, 0x0, 0x0, 0x0, 0x6f, 0xf0, + 0x0, 0x0, 0x0, 0x6f, 0xf0, 0x0, 0x0, 0x0, + 0x6f, 0xf0, 0x0, 0x0, 0x0, 0x6f, 0xf0, + + /* U+038C "Ό" */ + 0x0, 0xaf, 0xf3, 0x0, 0x5a, 0xdf, 0xfd, 0xa5, + 0x0, 0x0, 0x0, 0x2f, 0xf6, 0x3, 0xdf, 0xff, + 0xff, 0xff, 0xfd, 0x30, 0x0, 0x9, 0xf9, 0x4, + 0xff, 0xfa, 0x53, 0x25, 0xaf, 0xff, 0x40, 0x0, + 0x99, 0x2, 0xff, 0xd3, 0x0, 0x0, 0x0, 0x3e, + 0xff, 0x20, 0x0, 0x0, 0xbf, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xfb, 0x0, 0x0, 0x2f, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf3, 0x0, + 0x7, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0x80, 0x0, 0xaf, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xfb, 0x0, 0xc, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xd0, 0x0, + 0xdf, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xfe, 0x0, 0xc, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xd0, 0x0, 0xaf, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xfc, 0x0, 0x7, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0x80, 0x0, 0x2f, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xf3, 0x0, 0x0, 0xbf, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xfc, 0x0, 0x0, 0x2, + 0xff, 0xe2, 0x0, 0x0, 0x0, 0x2e, 0xff, 0x20, + 0x0, 0x0, 0x4, 0xff, 0xf9, 0x52, 0x25, 0xaf, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x3, 0xdf, 0xff, + 0xff, 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5a, 0xdf, 0xfd, 0xa5, 0x0, 0x0, 0x0, + + /* U+038E "Ύ" */ + 0x0, 0xaf, 0xf3, 0xd, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xf8, 0x2, 0xff, 0x60, 0x3, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xd0, + 0x9, 0xf9, 0x0, 0x0, 0x8f, 0xf6, 0x0, 0x0, + 0x0, 0x9, 0xff, 0x30, 0x9, 0x90, 0x0, 0x0, + 0xd, 0xff, 0x10, 0x0, 0x0, 0x3f, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xb0, 0x0, + 0x0, 0xdf, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xf5, 0x0, 0x8, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xfe, 0x0, + 0x2f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0x80, 0xcf, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf8, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0x70, 0x0, 0x0, 0x0, + + /* U+038F "Ώ" */ + 0x0, 0xaf, 0xf3, 0x0, 0x5b, 0xef, 0xfd, 0xa4, + 0x0, 0x0, 0x0, 0x2f, 0xf6, 0x2, 0xdf, 0xff, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x9, 0xf9, 0x2, + 0xef, 0xfb, 0x52, 0x36, 0xdf, 0xfc, 0x0, 0x0, + 0x99, 0x0, 0xdf, 0xf5, 0x0, 0x0, 0x0, 0x9f, + 0xf9, 0x0, 0x0, 0x0, 0x7f, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xf3, 0x0, 0x0, 0xe, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0x90, 0x0, + 0x2, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xfe, 0x0, 0x0, 0x5f, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xf0, 0x0, 0x6, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0x10, 0x0, + 0x5f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xf1, 0x0, 0x4, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0x0, 0x0, 0x1f, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xc0, 0x0, 0x0, + 0xbf, 0xa0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xf6, + 0x0, 0x0, 0x4, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x4, 0xfe, 0x0, 0x0, 0x0, 0xa, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0x50, 0x0, 0x0, 0x0, + 0xc, 0xf8, 0x0, 0x0, 0x0, 0xbf, 0x80, 0x0, + 0x0, 0x2, 0x33, 0x4e, 0xfb, 0x20, 0x4, 0xdf, + 0xb3, 0x33, 0x10, 0x0, 0xaf, 0xff, 0xff, 0xf9, + 0x0, 0xef, 0xff, 0xff, 0xf5, 0x0, 0xa, 0xff, + 0xff, 0xff, 0x90, 0xe, 0xff, 0xff, 0xff, 0x50, + + /* U+0390 "ΐ" */ + 0x0, 0x0, 0x18, 0x71, 0x0, 0x57, 0x30, 0x8f, + 0x95, 0x73, 0xbf, 0x70, 0xfd, 0xb, 0xf8, 0xbf, + 0x77, 0xf2, 0xb, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0x0, 0x0, 0x0, 0x4, 0xff, 0x0, 0x0, + 0x0, 0x4, 0xff, 0x0, 0x0, 0x0, 0x4, 0xff, + 0x0, 0x0, 0x0, 0x4, 0xff, 0x0, 0x0, 0x0, + 0x4, 0xff, 0x0, 0x0, 0x0, 0x4, 0xff, 0x0, + 0x0, 0x0, 0x4, 0xff, 0x0, 0x0, 0x0, 0x4, + 0xff, 0x0, 0x0, 0x0, 0x4, 0xff, 0x0, 0x0, + 0x0, 0x4, 0xff, 0x0, 0x0, 0x0, 0x4, 0xff, + 0x0, 0x0, 0x0, 0x4, 0xff, 0x0, 0x0, 0x0, + 0x4, 0xff, 0x0, 0x0, + + /* U+0391 "Α" */ + 0x0, 0x0, 0x0, 0x1, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfb, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0x2f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xb0, 0xcf, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xf6, 0x6, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0x10, 0x1f, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xa0, 0x0, + 0xaf, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf4, + 0x0, 0x4, 0xff, 0x30, 0x0, 0x0, 0x0, 0x7, + 0xfe, 0x0, 0x0, 0xe, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0x80, 0x0, 0x0, 0x8f, 0xf0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0xef, 0x80, 0x0, + 0x0, 0x0, 0x6f, 0xf3, 0x0, 0x0, 0x5f, 0xf2, + 0x0, 0x0, 0x0, 0x1, 0xff, 0x90, 0x0, 0xb, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0x0, + 0x1, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xf6, 0x0, 0x7f, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xc0, 0xd, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0x30, + + /* U+0392 "Β" */ + 0x1f, 0xff, 0xff, 0xff, 0xfd, 0xa4, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x1f, + 0xf8, 0x33, 0x34, 0x47, 0xdf, 0xf6, 0x1, 0xff, + 0x60, 0x0, 0x0, 0x0, 0xdf, 0xd0, 0x1f, 0xf6, + 0x0, 0x0, 0x0, 0x7, 0xff, 0x1, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x6f, 0xf0, 0x1f, 0xf6, 0x0, + 0x0, 0x0, 0xa, 0xfb, 0x1, 0xff, 0x60, 0x0, + 0x0, 0x39, 0xff, 0x30, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x30, 0x1, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x10, 0x1f, 0xf8, 0x33, 0x33, 0x46, + 0xaf, 0xfd, 0x1, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x4f, 0xf8, 0x1f, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xd1, 0xff, 0x60, 0x0, 0x0, 0x0, 0x9, + 0xff, 0x1f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xd1, 0xff, 0x60, 0x0, 0x0, 0x0, 0x3f, 0xf9, + 0x1f, 0xf8, 0x33, 0x33, 0x45, 0x9f, 0xff, 0x21, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, 0x1f, + 0xff, 0xff, 0xff, 0xfe, 0xc8, 0x10, 0x0, + + /* U+0393 "Γ" */ + 0xef, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0xef, 0xa3, 0x33, 0x33, + 0x33, 0x32, 0xef, 0x80, 0x0, 0x0, 0x0, 0x0, + 0xef, 0x80, 0x0, 0x0, 0x0, 0x0, 0xef, 0x80, + 0x0, 0x0, 0x0, 0x0, 0xef, 0x80, 0x0, 0x0, + 0x0, 0x0, 0xef, 0x80, 0x0, 0x0, 0x0, 0x0, + 0xef, 0x80, 0x0, 0x0, 0x0, 0x0, 0xef, 0x80, + 0x0, 0x0, 0x0, 0x0, 0xef, 0x80, 0x0, 0x0, + 0x0, 0x0, 0xef, 0x80, 0x0, 0x0, 0x0, 0x0, + 0xef, 0x80, 0x0, 0x0, 0x0, 0x0, 0xef, 0x80, + 0x0, 0x0, 0x0, 0x0, 0xef, 0x80, 0x0, 0x0, + 0x0, 0x0, 0xef, 0x80, 0x0, 0x0, 0x0, 0x0, + 0xef, 0x80, 0x0, 0x0, 0x0, 0x0, 0xef, 0x80, + 0x0, 0x0, 0x0, 0x0, 0xef, 0x80, 0x0, 0x0, + 0x0, 0x0, + + /* U+0394 "Δ" */ + 0x0, 0x0, 0x0, 0x1, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xfb, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0x3f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xb0, 0xcf, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xf6, 0x7, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0x10, 0x1f, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xb0, 0x0, + 0xbf, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf5, + 0x0, 0x5, 0xff, 0x20, 0x0, 0x0, 0x0, 0x7, + 0xff, 0x0, 0x0, 0xe, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xa0, 0x0, 0x0, 0x9f, 0xf0, 0x0, + 0x0, 0x0, 0x3f, 0xf4, 0x0, 0x0, 0x3, 0xff, + 0x60, 0x0, 0x0, 0x9, 0xfe, 0x0, 0x0, 0x0, + 0xd, 0xfc, 0x0, 0x0, 0x0, 0xef, 0x90, 0x0, + 0x0, 0x0, 0x7f, 0xf2, 0x0, 0x0, 0x5f, 0xf3, + 0x0, 0x0, 0x0, 0x1, 0xff, 0x90, 0x0, 0xb, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0x0, + 0x1, 0xff, 0xa3, 0x33, 0x33, 0x33, 0x33, 0x8f, + 0xf6, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xc0, 0xd, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x30, + + /* U+0395 "Ε" */ + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xff, 0xa3, + 0x33, 0x33, 0x33, 0x33, 0x31, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0xff, 0x93, + 0x33, 0x33, 0x33, 0x33, 0x20, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xa3, 0x33, 0x33, 0x33, 0x33, 0x33, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, + + /* U+0396 "Ζ" */ + 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, + 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, + 0x1, 0x33, 0x33, 0x33, 0x33, 0x38, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xdf, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2e, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xfb, 0x33, 0x33, 0x33, 0x33, 0x33, 0x30, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, + + /* U+0397 "Η" */ + 0xef, 0x80, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xbe, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfb, 0xef, + 0x80, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xbe, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xfb, 0xef, 0x80, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xbe, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xfb, 0xef, 0x80, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xbe, 0xfa, 0x33, 0x33, + 0x33, 0x33, 0x3d, 0xfb, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xbe, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0xef, 0x80, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xbe, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xfb, 0xef, 0x80, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xbe, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xfb, 0xef, 0x80, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xbe, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfb, + 0xef, 0x80, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xbe, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfb, 0xef, + 0x80, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xb0, + + /* U+0398 "Θ" */ + 0x0, 0x0, 0x4, 0x9d, 0xff, 0xeb, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x2c, 0xff, 0xff, 0xff, 0xff, + 0xd4, 0x0, 0x0, 0x0, 0x3e, 0xff, 0xb5, 0x32, + 0x49, 0xff, 0xf5, 0x0, 0x0, 0x1e, 0xfe, 0x40, + 0x0, 0x0, 0x2, 0xdf, 0xf3, 0x0, 0x9, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x1, 0xef, 0xd0, 0x1, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0x40, 0x5f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xf9, 0x9, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xd0, 0xbf, 0xd0, 0x9, 0xff, + 0xff, 0xff, 0xc0, 0x9, 0xfe, 0xc, 0xfc, 0x0, + 0x9f, 0xff, 0xff, 0xfc, 0x0, 0x8f, 0xf0, 0xbf, + 0xd0, 0x1, 0x33, 0x33, 0x33, 0x20, 0x9, 0xff, + 0x9, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xd0, 0x5f, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xf9, 0x0, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0x40, 0xa, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xd0, 0x0, 0x1e, + 0xfe, 0x30, 0x0, 0x0, 0x2, 0xdf, 0xf3, 0x0, + 0x0, 0x3f, 0xff, 0xa5, 0x32, 0x49, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x2c, 0xff, 0xff, 0xff, 0xff, + 0xd4, 0x0, 0x0, 0x0, 0x0, 0x4, 0xad, 0xff, + 0xeb, 0x60, 0x0, 0x0, 0x0, + + /* U+0399 "Ι" */ + 0x9f, 0xd9, 0xfd, 0x9f, 0xd9, 0xfd, 0x9f, 0xd9, + 0xfd, 0x9f, 0xd9, 0xfd, 0x9f, 0xd9, 0xfd, 0x9f, + 0xd9, 0xfd, 0x9f, 0xd9, 0xfd, 0x9f, 0xd9, 0xfd, + 0x9f, 0xd9, 0xfd, 0x9f, 0xd0, + + /* U+039A "Κ" */ + 0x1f, 0xf6, 0x0, 0x0, 0x0, 0x1, 0xcf, 0xf7, + 0x1, 0xff, 0x60, 0x0, 0x0, 0x0, 0xcf, 0xf7, + 0x0, 0x1f, 0xf6, 0x0, 0x0, 0x0, 0xcf, 0xf6, + 0x0, 0x1, 0xff, 0x60, 0x0, 0x0, 0xcf, 0xf6, + 0x0, 0x0, 0x1f, 0xf6, 0x0, 0x0, 0xcf, 0xf6, + 0x0, 0x0, 0x1, 0xff, 0x60, 0x0, 0xbf, 0xf6, + 0x0, 0x0, 0x0, 0x1f, 0xf6, 0x0, 0xbf, 0xf6, + 0x0, 0x0, 0x0, 0x1, 0xff, 0x60, 0xbf, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf6, 0xbf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xef, 0xfb, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf5, + 0xc, 0xff, 0x30, 0x0, 0x0, 0x1, 0xff, 0xf5, + 0x0, 0x2f, 0xfd, 0x0, 0x0, 0x0, 0x1f, 0xf7, + 0x0, 0x0, 0x6f, 0xf9, 0x0, 0x0, 0x1, 0xff, + 0x60, 0x0, 0x0, 0xbf, 0xf5, 0x0, 0x0, 0x1f, + 0xf6, 0x0, 0x0, 0x1, 0xff, 0xe1, 0x0, 0x1, + 0xff, 0x60, 0x0, 0x0, 0x5, 0xff, 0xc0, 0x0, + 0x1f, 0xf6, 0x0, 0x0, 0x0, 0xa, 0xff, 0x70, + 0x1, 0xff, 0x60, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0x30, 0x1f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xfd, 0x0, + + /* U+039B "Λ" */ + 0x0, 0x0, 0x0, 0xc, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xcf, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0x3e, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xfe, + 0x9, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xf9, 0x3, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xf3, 0x0, 0xef, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xd0, 0x0, 0x8f, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0x70, 0x0, 0x3f, 0xf2, 0x0, + 0x0, 0x0, 0x3, 0xff, 0x20, 0x0, 0xd, 0xf8, + 0x0, 0x0, 0x0, 0x9, 0xfc, 0x0, 0x0, 0x7, + 0xfe, 0x0, 0x0, 0x0, 0xf, 0xf6, 0x0, 0x0, + 0x2, 0xff, 0x50, 0x0, 0x0, 0x5f, 0xf0, 0x0, + 0x0, 0x0, 0xcf, 0xb0, 0x0, 0x0, 0xcf, 0xa0, + 0x0, 0x0, 0x0, 0x7f, 0xf1, 0x0, 0x2, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x1f, 0xf7, 0x0, 0x8, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0xb, 0xfd, 0x0, + 0xe, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0x30, 0x4f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0x90, 0xaf, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xf0, + + /* U+039C "Μ" */ + 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xb0, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xfb, 0xf, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xb0, 0xff, 0xcf, 0xc0, + 0x0, 0x0, 0x0, 0xc, 0xfd, 0xfb, 0xf, 0xf7, + 0xff, 0x20, 0x0, 0x0, 0x1, 0xfd, 0xaf, 0xb0, + 0xff, 0x5c, 0xf7, 0x0, 0x0, 0x0, 0x7f, 0x8a, + 0xfb, 0xf, 0xf5, 0x7f, 0xc0, 0x0, 0x0, 0xc, + 0xf2, 0xaf, 0xb0, 0xff, 0x51, 0xff, 0x10, 0x0, + 0x1, 0xfd, 0xa, 0xfb, 0xf, 0xf5, 0xc, 0xf7, + 0x0, 0x0, 0x7f, 0x80, 0xaf, 0xb0, 0xff, 0x50, + 0x7f, 0xc0, 0x0, 0xc, 0xf2, 0xa, 0xfb, 0xf, + 0xf5, 0x1, 0xff, 0x10, 0x2, 0xfd, 0x0, 0xaf, + 0xb0, 0xff, 0x50, 0xc, 0xf6, 0x0, 0x7f, 0x70, + 0xa, 0xfb, 0xf, 0xf5, 0x0, 0x7f, 0xc0, 0xc, + 0xf2, 0x0, 0xaf, 0xb0, 0xff, 0x50, 0x1, 0xff, + 0x12, 0xfc, 0x0, 0xa, 0xfb, 0xf, 0xf5, 0x0, + 0xc, 0xf6, 0x7f, 0x70, 0x0, 0xaf, 0xb0, 0xff, + 0x50, 0x0, 0x7f, 0xbc, 0xf2, 0x0, 0xa, 0xfb, + 0xf, 0xf5, 0x0, 0x1, 0xff, 0xfc, 0x0, 0x0, + 0xaf, 0xb0, 0xff, 0x50, 0x0, 0xc, 0xff, 0x70, + 0x0, 0xa, 0xfb, 0xf, 0xf5, 0x0, 0x0, 0x7f, + 0xf1, 0x0, 0x0, 0xaf, 0xb0, + + /* U+039D "Ν" */ + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xbf, + 0xff, 0x80, 0x0, 0x0, 0x0, 0xa, 0xfb, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0xaf, 0xbf, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0xa, 0xfb, 0xff, 0xbf, + 0xf8, 0x0, 0x0, 0x0, 0xaf, 0xbf, 0xf6, 0xaf, + 0xf3, 0x0, 0x0, 0xa, 0xfb, 0xff, 0x61, 0xef, + 0xd0, 0x0, 0x0, 0xaf, 0xbf, 0xf6, 0x5, 0xff, + 0x70, 0x0, 0xa, 0xfb, 0xff, 0x60, 0xa, 0xff, + 0x20, 0x0, 0xaf, 0xbf, 0xf6, 0x0, 0x1e, 0xfc, + 0x0, 0xa, 0xfb, 0xff, 0x60, 0x0, 0x5f, 0xf7, + 0x0, 0xaf, 0xbf, 0xf6, 0x0, 0x0, 0xbf, 0xf2, + 0xa, 0xfb, 0xff, 0x60, 0x0, 0x1, 0xff, 0xc0, + 0xaf, 0xbf, 0xf6, 0x0, 0x0, 0x6, 0xff, 0x6a, + 0xfb, 0xff, 0x60, 0x0, 0x0, 0xc, 0xff, 0xcf, + 0xbf, 0xf6, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfb, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xbf, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfb, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x2, 0xff, 0xb0, + + /* U+039E "Ξ" */ + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x24, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x3, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x30, 0x0, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x0, 0x1, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x23, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x19, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, + + /* U+039F "Ο" */ + 0x0, 0x0, 0x4, 0x9d, 0xff, 0xeb, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x2c, 0xff, 0xff, 0xff, 0xff, + 0xd4, 0x0, 0x0, 0x0, 0x3e, 0xff, 0xb5, 0x32, + 0x49, 0xff, 0xf5, 0x0, 0x0, 0x1e, 0xfe, 0x40, + 0x0, 0x0, 0x2, 0xdf, 0xf3, 0x0, 0x9, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x1, 0xef, 0xd0, 0x1, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0x40, 0x5f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xf9, 0x9, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xd0, 0xbf, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xfe, 0xc, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf0, 0xbf, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0x9, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xd0, 0x5f, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xf9, 0x0, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0x40, 0xa, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xd0, 0x0, 0x1e, + 0xfe, 0x30, 0x0, 0x0, 0x2, 0xdf, 0xf3, 0x0, + 0x0, 0x3f, 0xff, 0xa5, 0x32, 0x49, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x2c, 0xff, 0xff, 0xff, 0xff, + 0xd4, 0x0, 0x0, 0x0, 0x0, 0x4, 0xad, 0xff, + 0xeb, 0x60, 0x0, 0x0, 0x0, + + /* U+03A0 "Π" */ + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbe, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xef, + 0xa3, 0x33, 0x33, 0x33, 0x33, 0xdf, 0xbe, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xfb, 0xef, 0x80, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xbe, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xfb, 0xef, 0x80, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xbe, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xfb, 0xef, 0x80, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xbe, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xfb, 0xef, 0x80, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xbe, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xfb, 0xef, 0x80, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xbe, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xfb, 0xef, 0x80, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xbe, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfb, + 0xef, 0x80, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xbe, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfb, 0xef, + 0x80, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xb0, + + /* U+03A1 "Ρ" */ + 0xff, 0xff, 0xff, 0xff, 0xed, 0xa4, 0x0, 0xf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0xff, + 0x93, 0x33, 0x33, 0x47, 0xdf, 0xf6, 0xf, 0xf7, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xd0, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x8, 0xff, 0x1f, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf3, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x7, 0xff, 0x1f, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xe0, 0xff, 0x70, 0x0, 0x0, + 0x15, 0xcf, 0xf6, 0xf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xc6, 0x0, 0xf, 0xf9, 0x33, 0x33, 0x32, 0x0, + 0x0, 0x0, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A3 "Σ" */ + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x2, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x1f, + 0xfe, 0x43, 0x33, 0x33, 0x33, 0x31, 0x0, 0x4f, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xd1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xfe, 0x43, 0x33, 0x33, 0x33, 0x33, 0x2, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0x2f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x10, + + /* U+03A4 "Τ" */ + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x13, 0x33, 0x33, 0x7f, 0xf5, 0x33, 0x33, 0x31, + 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x0, + + /* U+03A5 "Υ" */ + 0x9f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xc0, 0xe, 0xfe, 0x10, 0x0, 0x0, 0x0, 0xb, + 0xff, 0x20, 0x4, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x5f, 0xf7, 0x0, 0x0, 0xaf, 0xf4, 0x0, 0x0, + 0x1, 0xef, 0xc0, 0x0, 0x0, 0x1e, 0xfe, 0x0, + 0x0, 0xa, 0xff, 0x20, 0x0, 0x0, 0x5, 0xff, + 0x90, 0x0, 0x4f, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xf3, 0x0, 0xdf, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xfc, 0x8, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0x8f, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfb, 0x0, + 0x0, 0x0, 0x0, + + /* U+03A6 "Φ" */ + 0x0, 0x0, 0x0, 0x0, 0x22, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xad, + 0xef, 0xff, 0xed, 0x93, 0x0, 0x0, 0x0, 0x2c, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x10, 0x0, + 0x1e, 0xff, 0x94, 0x2d, 0xfa, 0x25, 0xbf, 0xfd, + 0x0, 0xc, 0xfe, 0x30, 0x0, 0xdf, 0x90, 0x0, + 0x6f, 0xf9, 0x4, 0xff, 0x50, 0x0, 0xd, 0xf9, + 0x0, 0x0, 0xaf, 0xf2, 0xaf, 0xe0, 0x0, 0x0, + 0xdf, 0x90, 0x0, 0x2, 0xff, 0x6c, 0xfb, 0x0, + 0x0, 0xd, 0xf9, 0x0, 0x0, 0xf, 0xf9, 0xef, + 0xa0, 0x0, 0x0, 0xdf, 0x90, 0x0, 0x0, 0xdf, + 0xad, 0xfb, 0x0, 0x0, 0xd, 0xf9, 0x0, 0x0, + 0xe, 0xf9, 0xbf, 0xe0, 0x0, 0x0, 0xdf, 0x90, + 0x0, 0x2, 0xff, 0x66, 0xff, 0x50, 0x0, 0xd, + 0xf9, 0x0, 0x0, 0x8f, 0xf2, 0xd, 0xff, 0x30, + 0x0, 0xdf, 0x90, 0x0, 0x5f, 0xf9, 0x0, 0x3f, + 0xff, 0x93, 0xd, 0xf9, 0x14, 0xaf, 0xfd, 0x0, + 0x0, 0x3d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0x10, 0x0, 0x0, 0x6, 0xbf, 0xff, 0xff, 0xfe, + 0xa4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0x90, 0x0, 0x0, 0x0, 0x0, + + /* U+03A7 "Χ" */ + 0xa, 0xff, 0x30, 0x0, 0x0, 0x0, 0x6, 0xff, + 0x40, 0x1, 0xef, 0xe0, 0x0, 0x0, 0x0, 0x2f, + 0xf9, 0x0, 0x0, 0x4f, 0xfa, 0x0, 0x0, 0x0, + 0xdf, 0xd0, 0x0, 0x0, 0x9, 0xff, 0x50, 0x0, + 0x9, 0xff, 0x20, 0x0, 0x0, 0x0, 0xdf, 0xe1, + 0x0, 0x5f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xfb, 0x1, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0x5b, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x6e, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfa, + 0x5, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xe1, 0x0, 0xaf, 0xf5, 0x0, 0x0, 0x0, 0x9, + 0xff, 0x40, 0x0, 0x1e, 0xfe, 0x10, 0x0, 0x0, + 0x5f, 0xf8, 0x0, 0x0, 0x4, 0xff, 0xb0, 0x0, + 0x2, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x9f, 0xf6, + 0x0, 0xc, 0xff, 0x20, 0x0, 0x0, 0x0, 0xd, + 0xff, 0x20, 0x8f, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xc0, + + /* U+03A8 "Ψ" */ + 0x6f, 0xf1, 0x0, 0x0, 0x6f, 0xf1, 0x0, 0x0, + 0x5f, 0xf1, 0x6f, 0xf1, 0x0, 0x0, 0x6f, 0xf1, + 0x0, 0x0, 0x5f, 0xf1, 0x6f, 0xf1, 0x0, 0x0, + 0x6f, 0xf1, 0x0, 0x0, 0x5f, 0xf1, 0x6f, 0xf1, + 0x0, 0x0, 0x6f, 0xf1, 0x0, 0x0, 0x5f, 0xf1, + 0x6f, 0xf1, 0x0, 0x0, 0x6f, 0xf1, 0x0, 0x0, + 0x5f, 0xf1, 0x6f, 0xf1, 0x0, 0x0, 0x6f, 0xf1, + 0x0, 0x0, 0x6f, 0xf1, 0x5f, 0xf2, 0x0, 0x0, + 0x6f, 0xf1, 0x0, 0x0, 0x7f, 0xf0, 0x3f, 0xf5, + 0x0, 0x0, 0x6f, 0xf1, 0x0, 0x0, 0xaf, 0xe0, + 0xf, 0xfb, 0x0, 0x0, 0x6f, 0xf1, 0x0, 0x1, + 0xff, 0xa0, 0x9, 0xff, 0x60, 0x0, 0x6f, 0xf1, + 0x0, 0xb, 0xff, 0x40, 0x1, 0xef, 0xfb, 0x51, + 0x6f, 0xf1, 0x26, 0xdf, 0xfa, 0x0, 0x0, 0x2d, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x6c, 0xff, 0xff, 0xff, 0xfe, 0xa4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x7f, 0xf3, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xf1, 0x0, 0x0, 0x0, 0x0, + + /* U+03A9 "Ω" */ + 0x0, 0x0, 0x6, 0xbe, 0xff, 0xd9, 0x30, 0x0, + 0x0, 0x0, 0x3, 0xef, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xa4, 0x23, 0x7e, + 0xff, 0xb0, 0x0, 0x1, 0xef, 0xf4, 0x0, 0x0, + 0x0, 0xbf, 0xf7, 0x0, 0x9, 0xff, 0x50, 0x0, + 0x0, 0x0, 0xd, 0xff, 0x10, 0xf, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0x70, 0x4f, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xc0, 0x7f, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xe0, + 0x8f, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xf0, 0x7f, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf0, 0x6f, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xd0, 0x3f, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xa0, 0xd, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0x40, 0x6, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xfd, 0x0, 0x0, 0xcf, + 0x80, 0x0, 0x0, 0x0, 0x1e, 0xf3, 0x0, 0x0, + 0x1d, 0xf6, 0x0, 0x0, 0x1, 0xdf, 0x60, 0x0, + 0x23, 0x35, 0xff, 0xa1, 0x0, 0x6e, 0xfa, 0x33, + 0x30, 0xcf, 0xff, 0xff, 0xf7, 0x0, 0xff, 0xff, + 0xff, 0xf3, 0xcf, 0xff, 0xff, 0xf7, 0x0, 0xff, + 0xff, 0xff, 0xf3, + + /* U+03AA "Ϊ" */ + 0xa, 0xa3, 0x2, 0xaa, 0x10, 0xff, 0x60, 0x4f, + 0xf1, 0xf, 0xf6, 0x4, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xfd, 0x0, 0x0, 0x0, + 0xaf, 0xd0, 0x0, 0x0, 0xa, 0xfd, 0x0, 0x0, + 0x0, 0xaf, 0xd0, 0x0, 0x0, 0xa, 0xfd, 0x0, + 0x0, 0x0, 0xaf, 0xd0, 0x0, 0x0, 0xa, 0xfd, + 0x0, 0x0, 0x0, 0xaf, 0xd0, 0x0, 0x0, 0xa, + 0xfd, 0x0, 0x0, 0x0, 0xaf, 0xd0, 0x0, 0x0, + 0xa, 0xfd, 0x0, 0x0, 0x0, 0xaf, 0xd0, 0x0, + 0x0, 0xa, 0xfd, 0x0, 0x0, 0x0, 0xaf, 0xd0, + 0x0, 0x0, 0xa, 0xfd, 0x0, 0x0, 0x0, 0xaf, + 0xd0, 0x0, 0x0, 0xa, 0xfd, 0x0, 0x0, 0x0, + 0xaf, 0xd0, 0x0, 0x0, 0xa, 0xfd, 0x0, 0x0, + + /* U+03AB "Ϋ" */ + 0x0, 0x0, 0xa, 0xa4, 0x2, 0xaa, 0x10, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xf7, 0x3, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xf7, 0x3, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xc0, 0xe, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0xb, 0xff, 0x20, 0x4, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x5f, 0xf7, 0x0, 0x0, + 0xaf, 0xf4, 0x0, 0x0, 0x1, 0xef, 0xc0, 0x0, + 0x0, 0x1e, 0xfe, 0x0, 0x0, 0xa, 0xff, 0x20, + 0x0, 0x0, 0x5, 0xff, 0x90, 0x0, 0x4f, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf3, 0x0, 0xdf, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xfc, 0x8, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0x8f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xfb, 0x0, 0x0, 0x0, 0x0, + + /* U+03AC "ά" */ + 0x0, 0x0, 0x0, 0x5, 0x99, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x9e, + 0xfe, 0xa2, 0x6, 0xfe, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xe3, 0xaf, 0xa0, 0x1, 0xef, 0xe4, 0x0, + 0x5e, 0xee, 0xf6, 0x0, 0x7f, 0xf3, 0x0, 0x0, + 0x4f, 0xff, 0x20, 0xc, 0xfc, 0x0, 0x0, 0x0, + 0xcf, 0xe0, 0x0, 0xff, 0x80, 0x0, 0x0, 0x9, + 0xfb, 0x0, 0xf, 0xf7, 0x0, 0x0, 0x0, 0x7f, + 0x80, 0x0, 0xff, 0x70, 0x0, 0x0, 0x8, 0xf8, + 0x0, 0xf, 0xf8, 0x0, 0x0, 0x0, 0x9f, 0xb0, + 0x0, 0xcf, 0xc0, 0x0, 0x0, 0xe, 0xfe, 0x0, + 0x7, 0xff, 0x30, 0x0, 0x6, 0xff, 0xf1, 0x0, + 0xe, 0xfe, 0x30, 0x6, 0xfc, 0xff, 0x50, 0x0, + 0x3e, 0xff, 0xff, 0xff, 0x3b, 0xf9, 0x0, 0x0, + 0x19, 0xef, 0xea, 0x20, 0x6f, 0xe0, + + /* U+03AD "έ" */ + 0x0, 0x0, 0x9, 0x98, 0x0, 0x0, 0x0, 0x5f, + 0xf4, 0x0, 0x0, 0x0, 0xdf, 0x80, 0x0, 0x0, + 0x4, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5c, + 0xff, 0xd8, 0x10, 0x7, 0xff, 0xff, 0xff, 0xe2, + 0x1f, 0xf8, 0x11, 0x6e, 0xb0, 0x5f, 0xe0, 0x0, + 0x0, 0x0, 0x5f, 0xf0, 0x0, 0x0, 0x0, 0xe, + 0xfb, 0x30, 0x0, 0x0, 0x3, 0xef, 0xff, 0x70, + 0x0, 0x7, 0xff, 0xff, 0x60, 0x0, 0x5f, 0xf8, + 0x10, 0x0, 0x0, 0xaf, 0xc0, 0x0, 0x0, 0x0, + 0xbf, 0xb0, 0x0, 0x0, 0x40, 0x7f, 0xf6, 0x0, + 0x3c, 0xf8, 0xd, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x8d, 0xff, 0xd8, 0x10, + + /* U+03AE "ή" */ + 0x0, 0x0, 0x0, 0x79, 0x91, 0x0, 0x0, 0x0, + 0x1, 0xff, 0x80, 0x0, 0x0, 0x0, 0x9, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xd0, 0x5b, 0xef, + 0xd7, 0x0, 0x3f, 0xd8, 0xff, 0xff, 0xff, 0xb0, + 0x3f, 0xff, 0xb3, 0x2, 0xaf, 0xf5, 0x3f, 0xfb, + 0x0, 0x0, 0xe, 0xf9, 0x3f, 0xf4, 0x0, 0x0, + 0xa, 0xfa, 0x3f, 0xf1, 0x0, 0x0, 0x9, 0xfb, + 0x3f, 0xf0, 0x0, 0x0, 0x9, 0xfb, 0x3f, 0xf0, + 0x0, 0x0, 0x9, 0xfb, 0x3f, 0xf0, 0x0, 0x0, + 0x9, 0xfb, 0x3f, 0xf0, 0x0, 0x0, 0x9, 0xfb, + 0x3f, 0xf0, 0x0, 0x0, 0x9, 0xfb, 0x3f, 0xf0, + 0x0, 0x0, 0x9, 0xfb, 0x3f, 0xf0, 0x0, 0x0, + 0x9, 0xfb, 0x3f, 0xf0, 0x0, 0x0, 0x9, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x9, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xfb, + + /* U+03AF "ί" */ + 0x0, 0x99, 0x70, 0x7, 0xff, 0x30, 0xe, 0xf6, + 0x0, 0x6f, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xf0, 0x0, 0x4f, 0xf0, 0x0, + 0x4f, 0xf0, 0x0, 0x4f, 0xf0, 0x0, 0x4f, 0xf0, + 0x0, 0x4f, 0xf0, 0x0, 0x4f, 0xf0, 0x0, 0x4f, + 0xf0, 0x0, 0x4f, 0xf0, 0x0, 0x4f, 0xf0, 0x0, + 0x4f, 0xf0, 0x0, 0x4f, 0xf0, 0x0, 0x4f, 0xf0, + 0x0, 0x4f, 0xf0, 0x0, + + /* U+03B0 "ΰ" */ + 0x0, 0x0, 0x0, 0xff, 0x30, 0x0, 0x3, 0x75, + 0x6, 0xf9, 0x37, 0x50, 0x7, 0xfb, 0xd, 0xe1, + 0x7f, 0xc0, 0x7, 0xfb, 0x4f, 0x50, 0x7f, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf0, 0x0, 0x0, + 0xc, 0xf8, 0x4f, 0xf0, 0x0, 0x0, 0xc, 0xf8, + 0x4f, 0xf0, 0x0, 0x0, 0xc, 0xf8, 0x4f, 0xf0, + 0x0, 0x0, 0xc, 0xf8, 0x4f, 0xf0, 0x0, 0x0, + 0xc, 0xf8, 0x4f, 0xf0, 0x0, 0x0, 0xc, 0xf8, + 0x4f, 0xf0, 0x0, 0x0, 0xc, 0xf8, 0x4f, 0xf0, + 0x0, 0x0, 0xc, 0xf8, 0x3f, 0xf0, 0x0, 0x0, + 0xc, 0xf7, 0x2f, 0xf2, 0x0, 0x0, 0xe, 0xf6, + 0xf, 0xf8, 0x0, 0x0, 0x4f, 0xf2, 0x8, 0xff, + 0x70, 0x4, 0xef, 0xb0, 0x0, 0xbf, 0xff, 0xff, + 0xfd, 0x10, 0x0, 0x6, 0xce, 0xfd, 0x81, 0x0, + + /* U+03B1 "α" */ + 0x0, 0x1, 0x9e, 0xfe, 0xa2, 0x6, 0xfe, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xe3, 0xaf, 0xa0, 0x1, + 0xef, 0xe4, 0x0, 0x5e, 0xee, 0xf6, 0x0, 0x7f, + 0xf3, 0x0, 0x0, 0x4f, 0xff, 0x20, 0xc, 0xfc, + 0x0, 0x0, 0x0, 0xcf, 0xe0, 0x0, 0xff, 0x80, + 0x0, 0x0, 0x9, 0xfb, 0x0, 0xf, 0xf7, 0x0, + 0x0, 0x0, 0x7f, 0x80, 0x0, 0xff, 0x70, 0x0, + 0x0, 0x8, 0xf8, 0x0, 0xf, 0xf8, 0x0, 0x0, + 0x0, 0x9f, 0xb0, 0x0, 0xcf, 0xc0, 0x0, 0x0, + 0xe, 0xfe, 0x0, 0x7, 0xff, 0x30, 0x0, 0x6, + 0xff, 0xf1, 0x0, 0xe, 0xfe, 0x30, 0x6, 0xfc, + 0xff, 0x50, 0x0, 0x3e, 0xff, 0xff, 0xff, 0x3b, + 0xf9, 0x0, 0x0, 0x19, 0xef, 0xea, 0x20, 0x6f, + 0xe0, + + /* U+03B2 "β" */ + 0x0, 0x3, 0xae, 0xfe, 0xb4, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xf6, 0x0, 0x6, 0xff, 0x70, + 0x1, 0xaf, 0xf2, 0x0, 0xdf, 0x70, 0x0, 0x0, + 0xcf, 0x80, 0x1f, 0xf2, 0x0, 0x0, 0x8, 0xfa, + 0x2, 0xff, 0x10, 0x0, 0x0, 0xaf, 0x70, 0x3f, + 0xf0, 0x0, 0x0, 0x7f, 0xd0, 0x3, 0xff, 0x0, + 0xac, 0xfe, 0x90, 0x0, 0x3f, 0xf0, 0xf, 0xff, + 0xea, 0x30, 0x3, 0xff, 0x0, 0x1, 0x4a, 0xff, + 0x50, 0x3f, 0xf0, 0x0, 0x0, 0x9, 0xff, 0x23, + 0xff, 0x0, 0x0, 0x0, 0xf, 0xf8, 0x3f, 0xf1, + 0x0, 0x0, 0x0, 0xbf, 0xb3, 0xff, 0x20, 0x0, + 0x0, 0xa, 0xfc, 0x3f, 0xf5, 0x0, 0x0, 0x0, + 0xcf, 0xa3, 0xff, 0xc0, 0x0, 0x0, 0x2f, 0xf5, + 0x3f, 0xff, 0xa1, 0x0, 0x1c, 0xfd, 0x3, 0xff, + 0x7f, 0xfc, 0xcf, 0xfe, 0x20, 0x3f, 0xf0, 0x4b, + 0xef, 0xd9, 0x10, 0x3, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+03B3 "γ" */ + 0x8f, 0xe0, 0x0, 0x0, 0x0, 0xdf, 0x82, 0xff, + 0x30, 0x0, 0x0, 0x3f, 0xf2, 0xc, 0xf9, 0x0, + 0x0, 0x8, 0xfc, 0x0, 0x6f, 0xe0, 0x0, 0x0, + 0xef, 0x60, 0x1, 0xff, 0x40, 0x0, 0x4f, 0xf1, + 0x0, 0xb, 0xfa, 0x0, 0x9, 0xfa, 0x0, 0x0, + 0x5f, 0xf0, 0x0, 0xff, 0x40, 0x0, 0x0, 0xef, + 0x50, 0x5f, 0xe0, 0x0, 0x0, 0x9, 0xfa, 0xb, + 0xf9, 0x0, 0x0, 0x0, 0x3f, 0xf1, 0xff, 0x30, + 0x0, 0x0, 0x0, 0xdf, 0xcf, 0xd0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xa0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xfa, 0x0, 0x0, 0x0, + + /* U+03B4 "δ" */ + 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, + 0xbf, 0xfe, 0xee, 0xee, 0xee, 0x50, 0x0, 0xb, + 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xe3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xef, + 0x70, 0x0, 0x0, 0x0, 0x1, 0x9d, 0xff, 0xfc, + 0x10, 0x0, 0x0, 0x3e, 0xff, 0xdc, 0xff, 0xe2, + 0x0, 0x1, 0xef, 0xe3, 0x0, 0x9, 0xfe, 0x20, + 0x7, 0xff, 0x30, 0x0, 0x0, 0xaf, 0xc0, 0xc, + 0xfa, 0x0, 0x0, 0x0, 0x2f, 0xf3, 0xf, 0xf6, + 0x0, 0x0, 0x0, 0xe, 0xf6, 0xf, 0xf4, 0x0, + 0x0, 0x0, 0xd, 0xf8, 0xf, 0xf4, 0x0, 0x0, + 0x0, 0xd, 0xf8, 0xe, 0xf6, 0x0, 0x0, 0x0, + 0xe, 0xf7, 0xb, 0xfb, 0x0, 0x0, 0x0, 0x3f, + 0xf3, 0x5, 0xff, 0x40, 0x0, 0x0, 0xbf, 0xd0, + 0x0, 0xcf, 0xf6, 0x0, 0x2b, 0xff, 0x50, 0x0, + 0x1d, 0xff, 0xfe, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x7c, 0xff, 0xd9, 0x20, 0x0, + + /* U+03B5 "ε" */ + 0x0, 0x5c, 0xff, 0xd8, 0x10, 0x7, 0xff, 0xff, + 0xff, 0xe2, 0x1f, 0xf8, 0x11, 0x6e, 0xb0, 0x5f, + 0xe0, 0x0, 0x0, 0x0, 0x5f, 0xf0, 0x0, 0x0, + 0x0, 0xe, 0xfb, 0x30, 0x0, 0x0, 0x3, 0xef, + 0xff, 0x70, 0x0, 0x7, 0xff, 0xff, 0x60, 0x0, + 0x5f, 0xf8, 0x10, 0x0, 0x0, 0xaf, 0xc0, 0x0, + 0x0, 0x0, 0xbf, 0xb0, 0x0, 0x0, 0x40, 0x7f, + 0xf6, 0x0, 0x3c, 0xf8, 0xd, 0xff, 0xff, 0xff, + 0xf4, 0x0, 0x8d, 0xff, 0xd8, 0x10, + + /* U+03B6 "ζ" */ + 0x0, 0xf, 0xff, 0xff, 0xff, 0xf4, 0x0, 0xe, + 0xee, 0xee, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x8, + 0xfc, 0x20, 0x0, 0x0, 0x0, 0xbf, 0xa0, 0x0, + 0x0, 0x0, 0xb, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xb0, 0x0, 0x0, 0x0, 0x6, 0xfd, 0x10, + 0x0, 0x0, 0x0, 0x1f, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xa0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x8, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0xf, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xfd, 0x10, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xfb, 0x86, 0x30, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xfc, 0x10, 0x0, 0x19, 0xdf, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x1, 0xaf, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xe0, 0x0, 0x0, + 0x0, 0x2, 0xbf, 0x90, 0x0, 0x0, 0x0, 0x7f, + 0xfd, 0x10, 0x0, 0x0, 0x0, 0xcd, 0x80, 0x0, + + /* U+03B7 "η" */ + 0x3f, 0xd0, 0x5b, 0xef, 0xd7, 0x0, 0x3f, 0xd8, + 0xff, 0xff, 0xff, 0xb0, 0x3f, 0xff, 0xb3, 0x2, + 0xaf, 0xf5, 0x3f, 0xfb, 0x0, 0x0, 0xe, 0xf9, + 0x3f, 0xf4, 0x0, 0x0, 0xa, 0xfa, 0x3f, 0xf1, + 0x0, 0x0, 0x9, 0xfb, 0x3f, 0xf0, 0x0, 0x0, + 0x9, 0xfb, 0x3f, 0xf0, 0x0, 0x0, 0x9, 0xfb, + 0x3f, 0xf0, 0x0, 0x0, 0x9, 0xfb, 0x3f, 0xf0, + 0x0, 0x0, 0x9, 0xfb, 0x3f, 0xf0, 0x0, 0x0, + 0x9, 0xfb, 0x3f, 0xf0, 0x0, 0x0, 0x9, 0xfb, + 0x3f, 0xf0, 0x0, 0x0, 0x9, 0xfb, 0x3f, 0xf0, + 0x0, 0x0, 0x9, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x9, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xfb, + + /* U+03B8 "θ" */ + 0x0, 0x5, 0xbe, 0xfd, 0x81, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xe2, 0x0, 0x5, 0xff, 0x70, + 0x3, 0xdf, 0xd0, 0x0, 0xdf, 0x80, 0x0, 0x1, + 0xff, 0x50, 0x3f, 0xf1, 0x0, 0x0, 0x9, 0xfa, + 0x7, 0xfc, 0x0, 0x0, 0x0, 0x5f, 0xf0, 0x9f, + 0xa0, 0x0, 0x0, 0x3, 0xff, 0x1b, 0xf9, 0x0, + 0x0, 0x0, 0x1f, 0xf3, 0xcf, 0xed, 0xdd, 0xdd, + 0xdd, 0xff, 0x4d, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf4, 0xcf, 0x80, 0x0, 0x0, 0x1, 0xff, 0x4b, + 0xf9, 0x0, 0x0, 0x0, 0x2f, 0xf3, 0x9f, 0xb0, + 0x0, 0x0, 0x4, 0xff, 0x17, 0xfe, 0x0, 0x0, + 0x0, 0x7f, 0xf0, 0x3f, 0xf3, 0x0, 0x0, 0xb, + 0xfa, 0x0, 0xdf, 0xa0, 0x0, 0x3, 0xff, 0x50, + 0x5, 0xff, 0x80, 0x3, 0xdf, 0xd0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x5, 0xbe, + 0xfd, 0x81, 0x0, 0x0, + + /* U+03B9 "ι" */ + 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, + 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, + 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, + 0x4f, 0xf0, 0x4f, 0xf0, + + /* U+03BA "κ" */ + 0x4f, 0xf0, 0x0, 0x2, 0xef, 0xd1, 0x4f, 0xf0, + 0x0, 0x2e, 0xfd, 0x10, 0x4f, 0xf0, 0x2, 0xef, + 0xc1, 0x0, 0x4f, 0xf0, 0x2e, 0xfc, 0x0, 0x0, + 0x4f, 0xf2, 0xef, 0xc0, 0x0, 0x0, 0x4f, 0xfe, + 0xfc, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x4f, 0xfb, 0xff, 0xc0, 0x0, 0x0, + 0x4f, 0xf0, 0x5f, 0xf9, 0x0, 0x0, 0x4f, 0xf0, + 0x8, 0xff, 0x60, 0x0, 0x4f, 0xf0, 0x0, 0xbf, + 0xf3, 0x0, 0x4f, 0xf0, 0x0, 0x1d, 0xfe, 0x10, + 0x4f, 0xf0, 0x0, 0x2, 0xff, 0xc0, 0x4f, 0xf0, + 0x0, 0x0, 0x5f, 0xf9, + + /* U+03BB "λ" */ + 0x0, 0x8, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x2f, 0xf7, 0xff, 0x30, + 0x0, 0x0, 0x8, 0xfd, 0xd, 0xf8, 0x0, 0x0, + 0x0, 0xef, 0x70, 0x8f, 0xe0, 0x0, 0x0, 0x4f, + 0xf1, 0x2, 0xff, 0x40, 0x0, 0xa, 0xfb, 0x0, + 0xc, 0xfa, 0x0, 0x0, 0xff, 0x50, 0x0, 0x6f, + 0xf0, 0x0, 0x6f, 0xf0, 0x0, 0x0, 0xff, 0x60, + 0xc, 0xfa, 0x0, 0x0, 0xa, 0xfc, 0x2, 0xff, + 0x40, 0x0, 0x0, 0x4f, 0xf2, 0x8f, 0xe0, 0x0, + 0x0, 0x0, 0xef, 0x70, + + /* U+03BC "μ" */ + 0x3f, 0xf0, 0x0, 0x0, 0x9, 0xfa, 0x3f, 0xf0, + 0x0, 0x0, 0x9, 0xfa, 0x3f, 0xf0, 0x0, 0x0, + 0x9, 0xfa, 0x3f, 0xf0, 0x0, 0x0, 0x9, 0xfa, + 0x3f, 0xf0, 0x0, 0x0, 0x9, 0xfa, 0x3f, 0xf0, + 0x0, 0x0, 0x9, 0xfa, 0x3f, 0xf0, 0x0, 0x0, + 0x9, 0xfa, 0x3f, 0xf0, 0x0, 0x0, 0x9, 0xfa, + 0x3f, 0xf1, 0x0, 0x0, 0xa, 0xfa, 0x3f, 0xf4, + 0x0, 0x0, 0xd, 0xfa, 0x3f, 0xfb, 0x0, 0x0, + 0x4f, 0xfa, 0x3f, 0xff, 0xa3, 0x27, 0xff, 0xfa, + 0x3f, 0xfd, 0xff, 0xff, 0xfa, 0xfa, 0x3f, 0xf1, + 0x9e, 0xfc, 0x46, 0xfa, 0x3f, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf0, 0x0, 0x0, + 0x0, 0x0, + + /* U+03BD "ν" */ + 0x7f, 0xe0, 0x0, 0x0, 0x0, 0xdf, 0x82, 0xff, + 0x40, 0x0, 0x0, 0x3f, 0xf2, 0xc, 0xf9, 0x0, + 0x0, 0x8, 0xfc, 0x0, 0x6f, 0xe0, 0x0, 0x0, + 0xef, 0x60, 0x0, 0xff, 0x40, 0x0, 0x3f, 0xf1, + 0x0, 0xa, 0xfa, 0x0, 0x9, 0xfb, 0x0, 0x0, + 0x4f, 0xf0, 0x0, 0xef, 0x50, 0x0, 0x0, 0xef, + 0x50, 0x4f, 0xe0, 0x0, 0x0, 0x9, 0xfa, 0xa, + 0xf9, 0x0, 0x0, 0x0, 0x3f, 0xf0, 0xff, 0x30, + 0x0, 0x0, 0x0, 0xdf, 0x9f, 0xd0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xc0, 0x0, 0x0, + + /* U+03BE "ξ" */ + 0x0, 0x7, 0xce, 0xff, 0xc0, 0x0, 0x2e, 0xff, + 0xff, 0xeb, 0x0, 0xc, 0xfc, 0x30, 0x0, 0x0, + 0x1, 0xff, 0x20, 0x0, 0x0, 0x0, 0xf, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xc4, 0x10, 0x0, + 0x0, 0x1, 0xbf, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x5f, 0xff, 0xf9, 0x0, 0x0, 0x7f, 0xf9, 0x30, + 0x0, 0x0, 0x7f, 0xf3, 0x0, 0x0, 0x0, 0x2f, + 0xf5, 0x0, 0x0, 0x0, 0x9, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0x90, 0x0, 0x0, 0x0, 0xc, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xc0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0x70, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xe9, 0x74, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xfd, 0x20, 0x0, 0x1, 0x58, 0xbf, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf1, 0x0, 0x0, + 0x0, 0x2, 0xff, 0x10, 0x0, 0x0, 0x15, 0xdf, + 0xc0, 0x0, 0x0, 0x8, 0xff, 0xe2, 0x0, 0x0, + 0x0, 0xcd, 0x91, 0x0, + + /* U+03BF "ο" */ + 0x0, 0x0, 0x6c, 0xef, 0xe9, 0x20, 0x0, 0x0, + 0x2d, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0xdf, + 0xe5, 0x0, 0x2b, 0xff, 0x40, 0x7, 0xff, 0x30, + 0x0, 0x0, 0xbf, 0xd0, 0xc, 0xfa, 0x0, 0x0, + 0x0, 0x3f, 0xf3, 0xf, 0xf6, 0x0, 0x0, 0x0, + 0xe, 0xf7, 0xf, 0xf4, 0x0, 0x0, 0x0, 0xd, + 0xf8, 0xf, 0xf4, 0x0, 0x0, 0x0, 0xd, 0xf7, + 0xf, 0xf6, 0x0, 0x0, 0x0, 0xe, 0xf6, 0xc, + 0xfa, 0x0, 0x0, 0x0, 0x3f, 0xf3, 0x6, 0xff, + 0x30, 0x0, 0x0, 0xbf, 0xd0, 0x0, 0xdf, 0xe5, + 0x0, 0x2a, 0xff, 0x50, 0x0, 0x2d, 0xff, 0xfe, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x6c, 0xff, 0xea, + 0x20, 0x0, + + /* U+03C0 "π" */ + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf6, 0x6e, 0xee, 0xff, 0xee, 0xee, 0xee, 0xff, + 0xee, 0xe5, 0x0, 0x0, 0xef, 0x60, 0x0, 0x0, + 0xff, 0x50, 0x0, 0x0, 0x0, 0xef, 0x60, 0x0, + 0x0, 0xff, 0x50, 0x0, 0x0, 0x0, 0xef, 0x60, + 0x0, 0x0, 0xff, 0x50, 0x0, 0x0, 0x0, 0xef, + 0x60, 0x0, 0x0, 0xff, 0x50, 0x0, 0x0, 0x0, + 0xef, 0x60, 0x0, 0x0, 0xff, 0x50, 0x0, 0x0, + 0x0, 0xef, 0x60, 0x0, 0x0, 0xff, 0x50, 0x0, + 0x0, 0x0, 0xef, 0x60, 0x0, 0x0, 0xff, 0x50, + 0x0, 0x0, 0x0, 0xef, 0x60, 0x0, 0x0, 0xff, + 0x50, 0x0, 0x0, 0x0, 0xef, 0x60, 0x0, 0x0, + 0xff, 0x50, 0x0, 0x0, 0x0, 0xef, 0x60, 0x0, + 0x0, 0xff, 0x50, 0x0, 0x0, 0x0, 0xef, 0x60, + 0x0, 0x0, 0xff, 0x50, 0x0, 0x0, 0x0, 0xef, + 0x60, 0x0, 0x0, 0xff, 0x50, 0x0, + + /* U+03C1 "ρ" */ + 0x0, 0x3, 0xae, 0xfe, 0xb5, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xfa, 0x0, 0x3, 0xff, 0xa2, + 0x0, 0x7f, 0xf8, 0x0, 0xbf, 0xc0, 0x0, 0x0, + 0x5f, 0xf2, 0xf, 0xf5, 0x0, 0x0, 0x0, 0xdf, + 0x83, 0xff, 0x10, 0x0, 0x0, 0x9, 0xfb, 0x4f, + 0xf0, 0x0, 0x0, 0x0, 0x8f, 0xd5, 0xff, 0x0, + 0x0, 0x0, 0x7, 0xfd, 0x5f, 0xf1, 0x0, 0x0, + 0x0, 0x9f, 0xb5, 0xff, 0x40, 0x0, 0x0, 0xd, + 0xf8, 0x5f, 0xfb, 0x0, 0x0, 0x5, 0xff, 0x25, + 0xff, 0xfa, 0x10, 0x6, 0xff, 0x90, 0x5f, 0xfd, + 0xff, 0xef, 0xff, 0xb0, 0x5, 0xff, 0x7, 0xdf, + 0xfc, 0x60, 0x0, 0x5f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+03C2 "ς" */ + 0x0, 0x0, 0x49, 0xdf, 0xfe, 0xb1, 0x0, 0x1b, + 0xff, 0xff, 0xff, 0xf0, 0x1, 0xdf, 0xd5, 0x10, + 0x1, 0x30, 0xb, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x9f, 0x90, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0x50, 0x0, 0x0, + 0x0, 0x0, 0xef, 0x50, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0x90, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xfd, 0x40, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xfd, 0x83, 0x0, 0x0, + 0x0, 0x1a, 0xff, 0xff, 0xe5, 0x0, 0x0, 0x0, + 0x4, 0x8e, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0xef, 0x90, 0x0, 0x0, 0x0, 0x0, 0xdf, 0x90, + 0x0, 0x0, 0x23, 0x4b, 0xff, 0x50, 0x0, 0x0, + 0xdf, 0xff, 0xfa, 0x0, 0x0, 0x1, 0xef, 0xfc, + 0x50, 0x0, + + /* U+03C3 "σ" */ + 0x0, 0x0, 0x7c, 0xff, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x2d, 0xff, 0xff, 0xff, 0xff, 0xee, 0xe6, + 0x1, 0xdf, 0xe5, 0x0, 0x2a, 0xff, 0x40, 0x0, + 0x7, 0xff, 0x20, 0x0, 0x0, 0xcf, 0xd0, 0x0, + 0xd, 0xf9, 0x0, 0x0, 0x0, 0x4f, 0xf3, 0x0, + 0xf, 0xf5, 0x0, 0x0, 0x0, 0xf, 0xf6, 0x0, + 0x1f, 0xf3, 0x0, 0x0, 0x0, 0xe, 0xf7, 0x0, + 0x1f, 0xf3, 0x0, 0x0, 0x0, 0xd, 0xf7, 0x0, + 0xf, 0xf5, 0x0, 0x0, 0x0, 0xf, 0xf5, 0x0, + 0xd, 0xf9, 0x0, 0x0, 0x0, 0x3f, 0xf2, 0x0, + 0x7, 0xff, 0x20, 0x0, 0x0, 0xbf, 0xd0, 0x0, + 0x0, 0xdf, 0xe4, 0x0, 0x2b, 0xff, 0x40, 0x0, + 0x0, 0x2d, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x7c, 0xff, 0xd9, 0x20, 0x0, 0x0, + + /* U+03C4 "τ" */ + 0x6f, 0xff, 0xff, 0xff, 0xfa, 0x6e, 0xee, 0xff, + 0xee, 0xe9, 0x0, 0x0, 0xdf, 0x60, 0x0, 0x0, + 0x0, 0xdf, 0x60, 0x0, 0x0, 0x0, 0xdf, 0x60, + 0x0, 0x0, 0x0, 0xdf, 0x60, 0x0, 0x0, 0x0, + 0xdf, 0x60, 0x0, 0x0, 0x0, 0xdf, 0x60, 0x0, + 0x0, 0x0, 0xdf, 0x60, 0x0, 0x0, 0x0, 0xdf, + 0x60, 0x0, 0x0, 0x0, 0xdf, 0x60, 0x0, 0x0, + 0x0, 0xdf, 0x60, 0x0, 0x0, 0x0, 0xdf, 0x60, + 0x0, 0x0, 0x0, 0xdf, 0x60, 0x0, + + /* U+03C5 "υ" */ + 0x4f, 0xf0, 0x0, 0x0, 0xc, 0xf8, 0x4f, 0xf0, + 0x0, 0x0, 0xc, 0xf8, 0x4f, 0xf0, 0x0, 0x0, + 0xc, 0xf8, 0x4f, 0xf0, 0x0, 0x0, 0xc, 0xf8, + 0x4f, 0xf0, 0x0, 0x0, 0xc, 0xf8, 0x4f, 0xf0, + 0x0, 0x0, 0xc, 0xf8, 0x4f, 0xf0, 0x0, 0x0, + 0xc, 0xf8, 0x4f, 0xf0, 0x0, 0x0, 0xc, 0xf8, + 0x3f, 0xf0, 0x0, 0x0, 0xc, 0xf7, 0x2f, 0xf2, + 0x0, 0x0, 0xe, 0xf6, 0xf, 0xf8, 0x0, 0x0, + 0x4f, 0xf2, 0x8, 0xff, 0x70, 0x4, 0xef, 0xb0, + 0x0, 0xbf, 0xff, 0xff, 0xfd, 0x10, 0x0, 0x6, + 0xce, 0xfd, 0x81, 0x0, + + /* U+03C6 "φ" */ + 0x0, 0x1, 0x9e, 0x30, 0x8e, 0xfd, 0x91, 0x0, + 0x0, 0x2e, 0xff, 0x5, 0xff, 0xff, 0xfe, 0x20, + 0x0, 0xdf, 0xc3, 0x8, 0xfe, 0x11, 0xbf, 0xd0, + 0x7, 0xfe, 0x10, 0x9, 0xfb, 0x0, 0xe, 0xf5, + 0xc, 0xf9, 0x0, 0x9, 0xfa, 0x0, 0x9, 0xfa, + 0xf, 0xf5, 0x0, 0x9, 0xfa, 0x0, 0x7, 0xfd, + 0xf, 0xf4, 0x0, 0x9, 0xfa, 0x0, 0x7, 0xfe, + 0xf, 0xf5, 0x0, 0x9, 0xfa, 0x0, 0x8, 0xfd, + 0xd, 0xf9, 0x0, 0x9, 0xfa, 0x0, 0xc, 0xf9, + 0x9, 0xfe, 0x0, 0x9, 0xfa, 0x0, 0x3f, 0xf4, + 0x2, 0xff, 0xa0, 0x9, 0xfa, 0x1, 0xdf, 0xc0, + 0x0, 0x6f, 0xfc, 0x39, 0xfb, 0x5e, 0xfe, 0x10, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xc2, 0x0, + 0x0, 0x0, 0x29, 0xef, 0xff, 0xb5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xfa, 0x0, 0x0, 0x0, + + /* U+03C7 "χ" */ + 0x2f, 0xf5, 0x0, 0x0, 0x0, 0x9f, 0xd0, 0xa, + 0xfd, 0x0, 0x0, 0x2, 0xff, 0x50, 0x2, 0xff, + 0x50, 0x0, 0x9, 0xfd, 0x0, 0x0, 0x9f, 0xc0, + 0x0, 0x2f, 0xf4, 0x0, 0x0, 0x2f, 0xf4, 0x0, + 0xaf, 0xc0, 0x0, 0x0, 0x9, 0xfc, 0x2, 0xff, + 0x30, 0x0, 0x0, 0x1, 0xff, 0x4a, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xdf, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xae, 0xf5, 0x0, 0x0, 0x0, 0x4, 0xff, 0x17, + 0xfd, 0x0, 0x0, 0x0, 0xc, 0xf9, 0x0, 0xef, + 0x70, 0x0, 0x0, 0x5f, 0xf1, 0x0, 0x7f, 0xe0, + 0x0, 0x0, 0xdf, 0x80, 0x0, 0xe, 0xf8, 0x0, + 0x6, 0xff, 0x10, 0x0, 0x7, 0xff, 0x10, 0xe, + 0xf8, 0x0, 0x0, 0x0, 0xef, 0x90, 0x8f, 0xf1, + 0x0, 0x0, 0x0, 0x7f, 0xf2, + + /* U+03C8 "ψ" */ + 0x7f, 0xd0, 0x0, 0xe, 0xf6, 0x0, 0x4, 0xff, + 0x7f, 0xd0, 0x0, 0xe, 0xf6, 0x0, 0x4, 0xff, + 0x7f, 0xd0, 0x0, 0xe, 0xf6, 0x0, 0x4, 0xff, + 0x7f, 0xd0, 0x0, 0xe, 0xf6, 0x0, 0x4, 0xff, + 0x7f, 0xd0, 0x0, 0xe, 0xf6, 0x0, 0x4, 0xff, + 0x7f, 0xd0, 0x0, 0xe, 0xf6, 0x0, 0x4, 0xff, + 0x7f, 0xd0, 0x0, 0xe, 0xf6, 0x0, 0x4, 0xff, + 0x7f, 0xd0, 0x0, 0xe, 0xf6, 0x0, 0x5, 0xff, + 0x6f, 0xe0, 0x0, 0xe, 0xf6, 0x0, 0x6, 0xfe, + 0x4f, 0xf1, 0x0, 0xe, 0xf6, 0x0, 0x9, 0xfc, + 0xf, 0xf9, 0x0, 0xe, 0xf6, 0x0, 0x1f, 0xf8, + 0x7, 0xff, 0x92, 0xe, 0xf6, 0x5, 0xdf, 0xe1, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x30, + 0x0, 0x3, 0xad, 0xff, 0xff, 0xfc, 0x81, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xf6, 0x0, 0x0, 0x0, + + /* U+03C9 "ω" */ + 0x2, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0x60, 0x0, 0x9f, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xfe, 0x0, 0xf, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xf5, 0x5, 0xff, 0x0, 0x0, + 0x8, 0x82, 0x0, 0x0, 0xbf, 0xa0, 0x9f, 0xc0, + 0x0, 0x0, 0xff, 0x40, 0x0, 0x7, 0xfe, 0xc, + 0xf9, 0x0, 0x0, 0xf, 0xf4, 0x0, 0x0, 0x4f, + 0xf1, 0xdf, 0x70, 0x0, 0x0, 0xff, 0x40, 0x0, + 0x2, 0xff, 0x2d, 0xf7, 0x0, 0x0, 0xf, 0xf4, + 0x0, 0x0, 0x2f, 0xf2, 0xcf, 0x80, 0x0, 0x0, + 0xff, 0x50, 0x0, 0x4, 0xff, 0x1a, 0xfb, 0x0, + 0x0, 0x2f, 0xf6, 0x0, 0x0, 0x7f, 0xf0, 0x5f, + 0xf2, 0x0, 0x7, 0xff, 0xb0, 0x0, 0xd, 0xfa, + 0x0, 0xef, 0xc1, 0x4, 0xfd, 0x8f, 0x70, 0x8, + 0xff, 0x30, 0x4, 0xff, 0xfe, 0xff, 0x30, 0xdf, + 0xee, 0xff, 0x80, 0x0, 0x3, 0xbf, 0xeb, 0x30, + 0x1, 0x9e, 0xfc, 0x50, 0x0, + + /* U+03CA "ϊ" */ + 0xbf, 0xb0, 0xf, 0xf6, 0xbf, 0xb0, 0xf, 0xf6, + 0x7a, 0x70, 0x9, 0xa4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf0, 0x0, + 0x0, 0x4f, 0xf0, 0x0, 0x0, 0x4f, 0xf0, 0x0, + 0x0, 0x4f, 0xf0, 0x0, 0x0, 0x4f, 0xf0, 0x0, + 0x0, 0x4f, 0xf0, 0x0, 0x0, 0x4f, 0xf0, 0x0, + 0x0, 0x4f, 0xf0, 0x0, 0x0, 0x4f, 0xf0, 0x0, + 0x0, 0x4f, 0xf0, 0x0, 0x0, 0x4f, 0xf0, 0x0, + 0x0, 0x4f, 0xf0, 0x0, 0x0, 0x4f, 0xf0, 0x0, + 0x0, 0x4f, 0xf0, 0x0, + + /* U+03CB "ϋ" */ + 0x0, 0x7f, 0xf0, 0xb, 0xfa, 0x0, 0x0, 0x7f, + 0xf0, 0xb, 0xfa, 0x0, 0x0, 0x4a, 0x90, 0x7, + 0xa6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf0, + 0x0, 0x0, 0xc, 0xf8, 0x4f, 0xf0, 0x0, 0x0, + 0xc, 0xf8, 0x4f, 0xf0, 0x0, 0x0, 0xc, 0xf8, + 0x4f, 0xf0, 0x0, 0x0, 0xc, 0xf8, 0x4f, 0xf0, + 0x0, 0x0, 0xc, 0xf8, 0x4f, 0xf0, 0x0, 0x0, + 0xc, 0xf8, 0x4f, 0xf0, 0x0, 0x0, 0xc, 0xf8, + 0x4f, 0xf0, 0x0, 0x0, 0xc, 0xf8, 0x3f, 0xf0, + 0x0, 0x0, 0xc, 0xf7, 0x2f, 0xf2, 0x0, 0x0, + 0xe, 0xf6, 0xf, 0xf8, 0x0, 0x0, 0x4f, 0xf2, + 0x8, 0xff, 0x70, 0x4, 0xef, 0xb0, 0x0, 0xbf, + 0xff, 0xff, 0xfd, 0x10, 0x0, 0x6, 0xce, 0xfd, + 0x81, 0x0, + + /* U+03CC "ό" */ + 0x0, 0x0, 0x0, 0x7, 0x99, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6c, 0xef, 0xe9, 0x20, + 0x0, 0x0, 0x2d, 0xff, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0xdf, 0xe5, 0x0, 0x2b, 0xff, 0x40, 0x7, + 0xff, 0x30, 0x0, 0x0, 0xbf, 0xd0, 0xc, 0xfa, + 0x0, 0x0, 0x0, 0x3f, 0xf3, 0xf, 0xf6, 0x0, + 0x0, 0x0, 0xe, 0xf7, 0xf, 0xf4, 0x0, 0x0, + 0x0, 0xd, 0xf8, 0xf, 0xf4, 0x0, 0x0, 0x0, + 0xd, 0xf7, 0xf, 0xf6, 0x0, 0x0, 0x0, 0xe, + 0xf6, 0xc, 0xfa, 0x0, 0x0, 0x0, 0x3f, 0xf3, + 0x6, 0xff, 0x30, 0x0, 0x0, 0xbf, 0xd0, 0x0, + 0xdf, 0xe5, 0x0, 0x2a, 0xff, 0x50, 0x0, 0x2d, + 0xff, 0xfe, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x6c, + 0xff, 0xea, 0x20, 0x0, + + /* U+03CD "ύ" */ + 0x0, 0x0, 0x0, 0x89, 0x90, 0x0, 0x0, 0x0, + 0x3, 0xff, 0x60, 0x0, 0x0, 0x0, 0xb, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf0, 0x0, 0x0, + 0xc, 0xf8, 0x4f, 0xf0, 0x0, 0x0, 0xc, 0xf8, + 0x4f, 0xf0, 0x0, 0x0, 0xc, 0xf8, 0x4f, 0xf0, + 0x0, 0x0, 0xc, 0xf8, 0x4f, 0xf0, 0x0, 0x0, + 0xc, 0xf8, 0x4f, 0xf0, 0x0, 0x0, 0xc, 0xf8, + 0x4f, 0xf0, 0x0, 0x0, 0xc, 0xf8, 0x4f, 0xf0, + 0x0, 0x0, 0xc, 0xf8, 0x3f, 0xf0, 0x0, 0x0, + 0xc, 0xf7, 0x2f, 0xf2, 0x0, 0x0, 0xe, 0xf6, + 0xf, 0xf8, 0x0, 0x0, 0x4f, 0xf2, 0x8, 0xff, + 0x70, 0x4, 0xef, 0xb0, 0x0, 0xbf, 0xff, 0xff, + 0xfd, 0x10, 0x0, 0x6, 0xce, 0xfd, 0x81, 0x0, + + /* U+03CE "ώ" */ + 0x0, 0x0, 0x0, 0x0, 0x7, 0x99, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0x60, 0x0, 0x9f, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xfe, 0x0, 0xf, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xf5, 0x5, 0xff, 0x0, + 0x0, 0x8, 0x82, 0x0, 0x0, 0xbf, 0xa0, 0x9f, + 0xc0, 0x0, 0x0, 0xff, 0x40, 0x0, 0x7, 0xfe, + 0xc, 0xf9, 0x0, 0x0, 0xf, 0xf4, 0x0, 0x0, + 0x4f, 0xf1, 0xdf, 0x70, 0x0, 0x0, 0xff, 0x40, + 0x0, 0x2, 0xff, 0x2d, 0xf7, 0x0, 0x0, 0xf, + 0xf4, 0x0, 0x0, 0x2f, 0xf2, 0xcf, 0x80, 0x0, + 0x0, 0xff, 0x50, 0x0, 0x4, 0xff, 0x1a, 0xfb, + 0x0, 0x0, 0x2f, 0xf6, 0x0, 0x0, 0x7f, 0xf0, + 0x5f, 0xf2, 0x0, 0x7, 0xff, 0xb0, 0x0, 0xd, + 0xfa, 0x0, 0xef, 0xc1, 0x4, 0xfd, 0x8f, 0x70, + 0x8, 0xff, 0x30, 0x4, 0xff, 0xfe, 0xff, 0x30, + 0xdf, 0xee, 0xff, 0x80, 0x0, 0x3, 0xbf, 0xeb, + 0x30, 0x1, 0x9e, 0xfc, 0x50, 0x0, + + /* U+03F4 "ϴ" */ + 0x0, 0x0, 0x5, 0x84, 0x0, 0x27, 0x70, 0x1f, + 0xe3, 0x77, 0x4f, 0xe0, 0x8f, 0x54, 0xff, 0x4f, + 0xe1, 0xf9, 0x4, 0xff +}; + + +/*--------------------- + * GLYPH DESCRIPTION + *--------------------*/ + +static const lv_font_fmt_txt_glyph_dsc_t glyph_dsc[] = { + {.bitmap_index = 0, .adv_w = 0, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0} /* id = 0 reserved */, + {.bitmap_index = 0, .adv_w = 116, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 0, .adv_w = 116, .box_w = 4, .box_h = 19, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 38, .adv_w = 147, .box_w = 8, .box_h = 7, .ofs_x = 1, .ofs_y = 12}, + {.bitmap_index = 66, .adv_w = 231, .box_w = 15, .box_h = 19, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 209, .adv_w = 231, .box_w = 14, .box_h = 24, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 377, .adv_w = 370, .box_w = 21, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 577, .adv_w = 278, .box_w = 16, .box_h = 20, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 737, .adv_w = 79, .box_w = 3, .box_h = 7, .ofs_x = 1, .ofs_y = 12}, + {.bitmap_index = 748, .adv_w = 139, .box_w = 7, .box_h = 24, .ofs_x = 1, .ofs_y = -5}, + {.bitmap_index = 832, .adv_w = 139, .box_w = 8, .box_h = 24, .ofs_x = 0, .ofs_y = -5}, + {.bitmap_index = 928, .adv_w = 162, .box_w = 10, .box_h = 9, .ofs_x = 0, .ofs_y = 10}, + {.bitmap_index = 973, .adv_w = 243, .box_w = 13, .box_h = 13, .ofs_x = 1, .ofs_y = 3}, + {.bitmap_index = 1058, .adv_w = 116, .box_w = 3, .box_h = 7, .ofs_x = 2, .ofs_y = -4}, + {.bitmap_index = 1069, .adv_w = 139, .box_w = 8, .box_h = 3, .ofs_x = 0, .ofs_y = 6}, + {.bitmap_index = 1081, .adv_w = 116, .box_w = 3, .box_h = 3, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 1086, .adv_w = 116, .box_w = 8, .box_h = 19, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1162, .adv_w = 231, .box_w = 13, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1286, .adv_w = 231, .box_w = 8, .box_h = 19, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 1362, .adv_w = 231, .box_w = 14, .box_h = 19, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1495, .adv_w = 231, .box_w = 13, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1619, .adv_w = 231, .box_w = 14, .box_h = 19, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1752, .adv_w = 231, .box_w = 13, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1876, .adv_w = 231, .box_w = 13, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2000, .adv_w = 231, .box_w = 13, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2124, .adv_w = 231, .box_w = 13, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2248, .adv_w = 231, .box_w = 13, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2372, .adv_w = 116, .box_w = 3, .box_h = 14, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 2393, .adv_w = 116, .box_w = 3, .box_h = 18, .ofs_x = 2, .ofs_y = -4}, + {.bitmap_index = 2420, .adv_w = 243, .box_w = 13, .box_h = 14, .ofs_x = 1, .ofs_y = 2}, + {.bitmap_index = 2511, .adv_w = 243, .box_w = 13, .box_h = 8, .ofs_x = 1, .ofs_y = 6}, + {.bitmap_index = 2563, .adv_w = 243, .box_w = 13, .box_h = 14, .ofs_x = 1, .ofs_y = 2}, + {.bitmap_index = 2654, .adv_w = 231, .box_w = 13, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2778, .adv_w = 422, .box_w = 25, .box_h = 24, .ofs_x = 1, .ofs_y = -5}, + {.bitmap_index = 3078, .adv_w = 278, .box_w = 19, .box_h = 19, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 3259, .adv_w = 278, .box_w = 15, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3402, .adv_w = 300, .box_w = 17, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3564, .adv_w = 300, .box_w = 16, .box_h = 19, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 3716, .adv_w = 278, .box_w = 14, .box_h = 19, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 3849, .adv_w = 255, .box_w = 13, .box_h = 19, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 3973, .adv_w = 324, .box_w = 18, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4144, .adv_w = 300, .box_w = 15, .box_h = 19, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 4287, .adv_w = 116, .box_w = 3, .box_h = 19, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 4316, .adv_w = 208, .box_w = 11, .box_h = 19, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4421, .adv_w = 278, .box_w = 17, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4583, .adv_w = 231, .box_w = 13, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4707, .adv_w = 347, .box_w = 19, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4888, .adv_w = 300, .box_w = 15, .box_h = 19, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 5031, .adv_w = 324, .box_w = 19, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 5212, .adv_w = 278, .box_w = 15, .box_h = 19, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 5355, .adv_w = 324, .box_w = 19, .box_h = 21, .ofs_x = 1, .ofs_y = -2}, + {.bitmap_index = 5555, .adv_w = 300, .box_w = 17, .box_h = 19, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 5717, .adv_w = 278, .box_w = 15, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 5860, .adv_w = 255, .box_w = 16, .box_h = 19, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6012, .adv_w = 300, .box_w = 15, .box_h = 19, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 6155, .adv_w = 278, .box_w = 18, .box_h = 19, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6326, .adv_w = 393, .box_w = 25, .box_h = 19, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6564, .adv_w = 278, .box_w = 18, .box_h = 19, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6735, .adv_w = 278, .box_w = 18, .box_h = 19, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6906, .adv_w = 255, .box_w = 16, .box_h = 19, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7058, .adv_w = 116, .box_w = 6, .box_h = 24, .ofs_x = 1, .ofs_y = -5}, + {.bitmap_index = 7130, .adv_w = 116, .box_w = 8, .box_h = 19, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7206, .adv_w = 116, .box_w = 6, .box_h = 24, .ofs_x = 0, .ofs_y = -5}, + {.bitmap_index = 7278, .adv_w = 195, .box_w = 12, .box_h = 11, .ofs_x = 0, .ofs_y = 9}, + {.bitmap_index = 7344, .adv_w = 231, .box_w = 16, .box_h = 2, .ofs_x = -1, .ofs_y = -5}, + {.bitmap_index = 7360, .adv_w = 139, .box_w = 5, .box_h = 4, .ofs_x = 1, .ofs_y = 15}, + {.bitmap_index = 7370, .adv_w = 231, .box_w = 14, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7468, .adv_w = 231, .box_w = 13, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 7592, .adv_w = 208, .box_w = 12, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 7676, .adv_w = 231, .box_w = 13, .box_h = 19, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7800, .adv_w = 231, .box_w = 13, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 7891, .adv_w = 116, .box_w = 9, .box_h = 19, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7977, .adv_w = 231, .box_w = 13, .box_h = 19, .ofs_x = 0, .ofs_y = -5}, + {.bitmap_index = 8101, .adv_w = 231, .box_w = 12, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 8215, .adv_w = 92, .box_w = 4, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 8253, .adv_w = 92, .box_w = 7, .box_h = 24, .ofs_x = -2, .ofs_y = -5}, + {.bitmap_index = 8337, .adv_w = 208, .box_w = 12, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 8451, .adv_w = 92, .box_w = 3, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 8480, .adv_w = 347, .box_w = 19, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 8613, .adv_w = 231, .box_w = 12, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 8697, .adv_w = 231, .box_w = 14, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 8795, .adv_w = 231, .box_w = 13, .box_h = 19, .ofs_x = 1, .ofs_y = -5}, + {.bitmap_index = 8919, .adv_w = 231, .box_w = 13, .box_h = 19, .ofs_x = 0, .ofs_y = -5}, + {.bitmap_index = 9043, .adv_w = 139, .box_w = 9, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 9106, .adv_w = 208, .box_w = 12, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 9190, .adv_w = 116, .box_w = 7, .box_h = 19, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 9257, .adv_w = 231, .box_w = 12, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 9341, .adv_w = 208, .box_w = 13, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 9432, .adv_w = 300, .box_w = 19, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 9565, .adv_w = 208, .box_w = 13, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 9656, .adv_w = 208, .box_w = 13, .box_h = 19, .ofs_x = 0, .ofs_y = -5}, + {.bitmap_index = 9780, .adv_w = 208, .box_w = 13, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 9871, .adv_w = 139, .box_w = 9, .box_h = 24, .ofs_x = 0, .ofs_y = -5}, + {.bitmap_index = 9979, .adv_w = 108, .box_w = 3, .box_h = 24, .ofs_x = 2, .ofs_y = -5}, + {.bitmap_index = 10015, .adv_w = 139, .box_w = 8, .box_h = 24, .ofs_x = 0, .ofs_y = -5}, + {.bitmap_index = 10111, .adv_w = 243, .box_w = 14, .box_h = 6, .ofs_x = 1, .ofs_y = 6}, + {.bitmap_index = 10153, .adv_w = 116, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 10153, .adv_w = 231, .box_w = 14, .box_h = 20, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 10293, .adv_w = 231, .box_w = 14, .box_h = 13, .ofs_x = 0, .ofs_y = 3}, + {.bitmap_index = 10384, .adv_w = 231, .box_w = 15, .box_h = 19, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 10527, .adv_w = 108, .box_w = 3, .box_h = 24, .ofs_x = 2, .ofs_y = -5}, + {.bitmap_index = 10563, .adv_w = 231, .box_w = 13, .box_h = 24, .ofs_x = 1, .ofs_y = -5}, + {.bitmap_index = 10719, .adv_w = 139, .box_w = 8, .box_h = 3, .ofs_x = 0, .ofs_y = 16}, + {.bitmap_index = 10731, .adv_w = 307, .box_w = 20, .box_h = 20, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 10931, .adv_w = 156, .box_w = 10, .box_h = 10, .ofs_x = 0, .ofs_y = 9}, + {.bitmap_index = 10981, .adv_w = 231, .box_w = 12, .box_h = 12, .ofs_x = 1, .ofs_y = 1}, + {.bitmap_index = 11053, .adv_w = 243, .box_w = 13, .box_h = 8, .ofs_x = 1, .ofs_y = 6}, + {.bitmap_index = 11105, .adv_w = 139, .box_w = 8, .box_h = 3, .ofs_x = 0, .ofs_y = 6}, + {.bitmap_index = 11117, .adv_w = 307, .box_w = 20, .box_h = 20, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 11317, .adv_w = 166, .box_w = 8, .box_h = 9, .ofs_x = 1, .ofs_y = 11}, + {.bitmap_index = 11353, .adv_w = 243, .box_w = 13, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 11457, .adv_w = 139, .box_w = 9, .box_h = 10, .ofs_x = 0, .ofs_y = 9}, + {.bitmap_index = 11502, .adv_w = 139, .box_w = 9, .box_h = 10, .ofs_x = 0, .ofs_y = 9}, + {.bitmap_index = 11547, .adv_w = 231, .box_w = 12, .box_h = 19, .ofs_x = 1, .ofs_y = -5}, + {.bitmap_index = 11661, .adv_w = 223, .box_w = 15, .box_h = 24, .ofs_x = -1, .ofs_y = -5}, + {.bitmap_index = 11841, .adv_w = 117, .box_w = 3, .box_h = 3, .ofs_x = 2, .ofs_y = 8}, + {.bitmap_index = 11846, .adv_w = 231, .box_w = 12, .box_h = 12, .ofs_x = 1, .ofs_y = 1}, + {.bitmap_index = 11918, .adv_w = 347, .box_w = 21, .box_h = 21, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 12139, .adv_w = 139, .box_w = 6, .box_h = 4, .ofs_x = 2, .ofs_y = 16}, + {.bitmap_index = 12151, .adv_w = 278, .box_w = 19, .box_h = 19, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 12332, .adv_w = 326, .box_w = 21, .box_h = 19, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 12532, .adv_w = 349, .box_w = 22, .box_h = 19, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 12741, .adv_w = 160, .box_w = 10, .box_h = 19, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 12836, .adv_w = 322, .box_w = 21, .box_h = 19, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 13036, .adv_w = 356, .box_w = 24, .box_h = 19, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 13264, .adv_w = 313, .box_w = 21, .box_h = 19, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 13464, .adv_w = 92, .box_w = 10, .box_h = 20, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 13564, .adv_w = 278, .box_w = 19, .box_h = 19, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 13745, .adv_w = 278, .box_w = 15, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 13888, .adv_w = 229, .box_w = 12, .box_h = 19, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 14002, .adv_w = 278, .box_w = 19, .box_h = 19, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 14183, .adv_w = 278, .box_w = 14, .box_h = 19, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 14316, .adv_w = 255, .box_w = 16, .box_h = 19, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 14468, .adv_w = 300, .box_w = 15, .box_h = 19, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 14611, .adv_w = 324, .box_w = 19, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 14792, .adv_w = 116, .box_w = 3, .box_h = 19, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 14821, .adv_w = 278, .box_w = 17, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 14983, .adv_w = 278, .box_w = 18, .box_h = 19, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 15154, .adv_w = 347, .box_w = 19, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 15335, .adv_w = 300, .box_w = 15, .box_h = 19, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 15478, .adv_w = 270, .box_w = 15, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 15621, .adv_w = 324, .box_w = 19, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 15802, .adv_w = 300, .box_w = 15, .box_h = 19, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 15945, .adv_w = 278, .box_w = 15, .box_h = 19, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 16088, .adv_w = 257, .box_w = 15, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 16231, .adv_w = 255, .box_w = 16, .box_h = 19, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 16383, .adv_w = 278, .box_w = 18, .box_h = 19, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 16554, .adv_w = 332, .box_w = 19, .box_h = 21, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 16754, .adv_w = 278, .box_w = 18, .box_h = 19, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 16925, .adv_w = 348, .box_w = 20, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 17115, .adv_w = 311, .box_w = 18, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 17286, .adv_w = 116, .box_w = 9, .box_h = 23, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 17390, .adv_w = 278, .box_w = 18, .box_h = 23, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 17597, .adv_w = 241, .box_w = 15, .box_h = 20, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 17747, .adv_w = 185, .box_w = 10, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 17847, .adv_w = 231, .box_w = 12, .box_h = 25, .ofs_x = 1, .ofs_y = -5}, + {.bitmap_index = 17997, .adv_w = 92, .box_w = 6, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 18057, .adv_w = 228, .box_w = 12, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 18177, .adv_w = 241, .box_w = 15, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 18282, .adv_w = 239, .box_w = 13, .box_h = 24, .ofs_x = 1, .ofs_y = -5}, + {.bitmap_index = 18438, .adv_w = 208, .box_w = 13, .box_h = 19, .ofs_x = 0, .ofs_y = -5}, + {.bitmap_index = 18562, .adv_w = 232, .box_w = 14, .box_h = 19, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 18695, .adv_w = 185, .box_w = 10, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 18765, .adv_w = 183, .box_w = 12, .box_h = 24, .ofs_x = 0, .ofs_y = -5}, + {.bitmap_index = 18909, .adv_w = 231, .box_w = 12, .box_h = 19, .ofs_x = 1, .ofs_y = -5}, + {.bitmap_index = 19023, .adv_w = 231, .box_w = 13, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 19147, .adv_w = 92, .box_w = 4, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 19175, .adv_w = 207, .box_w = 12, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 19259, .adv_w = 208, .box_w = 13, .box_h = 19, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 19383, .adv_w = 231, .box_w = 12, .box_h = 19, .ofs_x = 1, .ofs_y = -5}, + {.bitmap_index = 19497, .adv_w = 208, .box_w = 13, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 19588, .adv_w = 186, .box_w = 11, .box_h = 24, .ofs_x = 1, .ofs_y = -5}, + {.bitmap_index = 19720, .adv_w = 231, .box_w = 14, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 19818, .adv_w = 287, .box_w = 18, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 19944, .adv_w = 237, .box_w = 13, .box_h = 19, .ofs_x = 1, .ofs_y = -5}, + {.bitmap_index = 20068, .adv_w = 200, .box_w = 12, .box_h = 19, .ofs_x = 1, .ofs_y = -5}, + {.bitmap_index = 20182, .adv_w = 257, .box_w = 16, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 20294, .adv_w = 164, .box_w = 10, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 20364, .adv_w = 228, .box_w = 12, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 20448, .adv_w = 270, .box_w = 16, .box_h = 19, .ofs_x = 0, .ofs_y = -5}, + {.bitmap_index = 20600, .adv_w = 218, .box_w = 14, .box_h = 19, .ofs_x = 0, .ofs_y = -5}, + {.bitmap_index = 20733, .adv_w = 297, .box_w = 16, .box_h = 19, .ofs_x = 1, .ofs_y = -5}, + {.bitmap_index = 20885, .adv_w = 325, .box_w = 19, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 21018, .adv_w = 92, .box_w = 8, .box_h = 19, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 21094, .adv_w = 228, .box_w = 12, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 21208, .adv_w = 231, .box_w = 14, .box_h = 20, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 21348, .adv_w = 228, .box_w = 12, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 21468, .adv_w = 325, .box_w = 19, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 21658, .adv_w = 139, .box_w = 10, .box_h = 4, .ofs_x = -1, .ofs_y = 16} +}; + +/*--------------------- + * CHARACTER MAPPING + *--------------------*/ + +static const uint8_t glyph_id_ofs_list_1[] = { + 0, 0, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 0, + 13, 14, 15, 16, 0, 17, 18, 19, + 0, 0, 0, 20, 0, 21 +}; + +static const uint8_t glyph_id_ofs_list_2[] = { + 0, 0, 1, 0, 2, 3, 4, 0, + 5 +}; + +/*Collect the unicode lists and glyph_id offsets*/ +static const lv_font_fmt_txt_cmap_t cmaps[] = +{ + { + .range_start = 32, .range_length = 95, .glyph_id_start = 1, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 160, .range_length = 30, .glyph_id_start = 96, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_1, .list_length = 30, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 900, .range_length = 9, .glyph_id_start = 118, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_2, .list_length = 9, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 910, .range_length = 20, .glyph_id_start = 124, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 931, .range_length = 44, .glyph_id_start = 144, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 1012, .range_length = 1, .glyph_id_start = 188, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + } +}; + + + +/*-------------------- + * ALL CUSTOM DATA + *--------------------*/ + +#if LVGL_VERSION_MAJOR == 8 +/*Store all the custom data of the font*/ +static lv_font_fmt_txt_glyph_cache_t cache; +#endif + +#if LVGL_VERSION_MAJOR >= 8 +static const lv_font_fmt_txt_dsc_t font_dsc = { +#else +static lv_font_fmt_txt_dsc_t font_dsc = { +#endif + .glyph_bitmap = glyph_bitmap, + .glyph_dsc = glyph_dsc, + .cmaps = cmaps, + .kern_dsc = NULL, + .kern_scale = 0, + .cmap_num = 6, + .bpp = 4, + .kern_classes = 0, + .bitmap_format = 0, +#if LVGL_VERSION_MAJOR == 8 + .cache = &cache +#endif + +}; + +extern const lv_font_t lv_font_montserrat_26; + + +/*----------------- + * PUBLIC FONT + *----------------*/ + +/*Initialize a public general font descriptor*/ +#if LVGL_VERSION_MAJOR >= 8 +const lv_font_t lv_font_arial_26 = { +#else +lv_font_t lv_font_arial_26 = { +#endif + .get_glyph_dsc = lv_font_get_glyph_dsc_fmt_txt, /*Function pointer to get glyph's data*/ + .get_glyph_bitmap = lv_font_get_bitmap_fmt_txt, /*Function pointer to get glyph's bitmap*/ + .line_height = 28, /*The maximum line height required by the font*/ + .base_line = 5, /*Baseline measured from the bottom of the line*/ +#if !(LVGL_VERSION_MAJOR == 6 && LVGL_VERSION_MINOR == 0) + .subpx = LV_FONT_SUBPX_NONE, +#endif +#if LV_VERSION_CHECK(7, 4, 0) || LVGL_VERSION_MAJOR >= 8 + .underline_position = -3, + .underline_thickness = 2, +#endif + .dsc = &font_dsc, /*The custom font data. Will be accessed by `get_glyph_bitmap/dsc` */ +#if LV_VERSION_CHECK(8, 2, 0) || LVGL_VERSION_MAJOR >= 9 + .fallback = &lv_font_montserrat_26, +#endif + .user_data = NULL, +}; + + + +#endif /*#if LV_FONT_ARIAL_26*/ diff --git a/src/fonts/lv_font_arial_28.c b/src/fonts/lv_font_arial_28.c new file mode 100644 index 0000000000..d8bb3b8ec1 --- /dev/null +++ b/src/fonts/lv_font_arial_28.c @@ -0,0 +1,3858 @@ +/******************************************************************************* + * Size: 28 px + * Bpp: 4 + * Opts: --bpp 4 --size 28 --no-compress --stride 1 --align 1 --font Arial Greek Regular.ttf --range 32-127,160-255,880-1023 --format lvgl -o lv_font_arial_28.c + ******************************************************************************/ + +#ifdef __has_include + #if __has_include("lvgl.h") + #ifndef LV_LVGL_H_INCLUDE_SIMPLE + #define LV_LVGL_H_INCLUDE_SIMPLE + #endif + #endif +#endif + +#ifdef LV_LVGL_H_INCLUDE_SIMPLE + #include "lvgl.h" +#else + #include "lvgl/lvgl.h" +#endif + + + +#ifndef LV_FONT_ARIAL_28 +#define LV_FONT_ARIAL_28 1 +#endif + +#if LV_FONT_ARIAL_28 + +/*----------------- + * BITMAPS + *----------------*/ + +/*Store the image of the glyphs*/ +static LV_ATTRIBUTE_LARGE_CONST const uint8_t glyph_bitmap[] = { + /* U+0020 " " */ + + /* U+0021 "!" */ + 0xaf, 0xf6, 0xaf, 0xf6, 0xaf, 0xf6, 0xaf, 0xf6, + 0xaf, 0xf6, 0x9f, 0xf5, 0x8f, 0xf4, 0x6f, 0xf3, + 0x5f, 0xf2, 0x4f, 0xf1, 0x3f, 0xf0, 0x2f, 0xf0, + 0x1f, 0xe0, 0xf, 0xd0, 0xe, 0xb0, 0x3, 0x20, + 0x0, 0x0, 0x7d, 0xd4, 0x8f, 0xf5, 0x8f, 0xf5, + + /* U+0022 "\"" */ + 0xbf, 0xf1, 0x2f, 0xfa, 0xbf, 0xf1, 0x2f, 0xfa, + 0xbf, 0xf1, 0x2f, 0xfa, 0xaf, 0xf1, 0x1f, 0xf9, + 0x7f, 0xe0, 0xf, 0xf7, 0x5f, 0xc0, 0xc, 0xf4, + 0x2f, 0x90, 0x9, 0xf1, 0x2, 0x10, 0x1, 0x20, + + /* U+0023 "#" */ + 0x0, 0x0, 0x7, 0xf9, 0x0, 0x1, 0xff, 0x0, + 0x0, 0x0, 0xa, 0xf5, 0x0, 0x5, 0xfb, 0x0, + 0x0, 0x0, 0xe, 0xf1, 0x0, 0x9, 0xf7, 0x0, + 0x0, 0x0, 0x2f, 0xe0, 0x0, 0xc, 0xf4, 0x0, + 0x0, 0x0, 0x6f, 0xa0, 0x0, 0xf, 0xf0, 0x0, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0x1, 0x11, 0xff, 0x11, 0x11, 0xaf, 0x71, 0x10, + 0x0, 0x3, 0xfd, 0x0, 0x0, 0xdf, 0x30, 0x0, + 0x0, 0x6, 0xf9, 0x0, 0x1, 0xff, 0x0, 0x0, + 0x0, 0xa, 0xf6, 0x0, 0x4, 0xfc, 0x0, 0x0, + 0x0, 0xd, 0xf3, 0x0, 0x7, 0xf9, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0x0, 0x7f, 0xa0, 0x0, 0x2f, 0xf0, 0x0, 0x0, + 0x0, 0xaf, 0x60, 0x0, 0x4f, 0xc0, 0x0, 0x0, + 0x0, 0xdf, 0x30, 0x0, 0x7f, 0x90, 0x0, 0x0, + 0x0, 0xff, 0x0, 0x0, 0xaf, 0x50, 0x0, 0x0, + 0x3, 0xfd, 0x0, 0x0, 0xef, 0x20, 0x0, 0x0, + 0x6, 0xf9, 0x0, 0x1, 0xff, 0x0, 0x0, 0x0, + + /* U+0024 "$" */ + 0x0, 0x0, 0x0, 0x73, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xf9, 0x20, 0x0, 0x0, 0x0, 0x2a, + 0xff, 0xff, 0xfd, 0x50, 0x0, 0x2, 0xef, 0xfe, + 0xff, 0xff, 0xf7, 0x0, 0xc, 0xff, 0x50, 0xf7, + 0x3d, 0xff, 0x20, 0x3f, 0xf6, 0x0, 0xf7, 0x3, + 0xff, 0x80, 0x7f, 0xf0, 0x0, 0xf7, 0x0, 0xde, + 0x90, 0x7f, 0xf0, 0x0, 0xf7, 0x0, 0x0, 0x0, + 0x6f, 0xf4, 0x0, 0xf7, 0x0, 0x0, 0x0, 0x1f, + 0xfd, 0x20, 0xf7, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xf9, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xc6, 0x0, 0x0, 0x0, 0x2, 0x9e, 0xff, + 0xff, 0xe4, 0x0, 0x0, 0x0, 0x0, 0xfb, 0xcf, + 0xff, 0x30, 0x0, 0x0, 0x0, 0xf7, 0x5, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0xf7, 0x0, 0x9f, 0xf2, + 0x14, 0x30, 0x0, 0xf7, 0x0, 0x4f, 0xf4, 0xef, + 0xc0, 0x0, 0xf7, 0x0, 0x4f, 0xf4, 0xbf, 0xf1, + 0x0, 0xf7, 0x0, 0x7f, 0xf1, 0x6f, 0xf9, 0x0, + 0xf7, 0x1, 0xef, 0xc0, 0xd, 0xff, 0x92, 0xf8, + 0x5e, 0xff, 0x30, 0x1, 0xdf, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x6, 0xcf, 0xff, 0xea, 0x30, + 0x0, 0x0, 0x0, 0x0, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x73, 0x0, 0x0, 0x0, + + /* U+0025 "%" */ + 0x0, 0x4c, 0xff, 0xb3, 0x0, 0x0, 0x0, 0x5, + 0xfa, 0x0, 0x0, 0x0, 0x4f, 0xfc, 0xdf, 0xf3, + 0x0, 0x0, 0x0, 0xdf, 0x20, 0x0, 0x0, 0xd, + 0xf7, 0x0, 0x7f, 0xc0, 0x0, 0x0, 0x6f, 0x90, + 0x0, 0x0, 0x2, 0xff, 0x0, 0x0, 0xff, 0x10, + 0x0, 0xe, 0xf1, 0x0, 0x0, 0x0, 0x4f, 0xd0, + 0x0, 0xe, 0xf3, 0x0, 0x8, 0xf7, 0x0, 0x0, + 0x0, 0x4, 0xfe, 0x0, 0x0, 0xff, 0x30, 0x1, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf1, 0x0, + 0x2f, 0xf0, 0x0, 0xaf, 0x60, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xa1, 0x1b, 0xfa, 0x0, 0x2f, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0xfd, + 0x10, 0xb, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x7a, 0xa6, 0x0, 0x4, 0xfb, 0x0, 0x17, + 0xaa, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0x30, 0x1d, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xa0, 0xa, 0xfb, 0x12, + 0xcf, 0x80, 0x0, 0x0, 0x0, 0x0, 0xe, 0xf2, + 0x1, 0xff, 0x20, 0x3, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xf9, 0x0, 0x4f, 0xe0, 0x0, 0xf, + 0xf2, 0x0, 0x0, 0x0, 0x1, 0xff, 0x10, 0x5, + 0xfd, 0x0, 0x0, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x9f, 0x70, 0x0, 0x4f, 0xd0, 0x0, 0xf, 0xf2, + 0x0, 0x0, 0x0, 0x2f, 0xe0, 0x0, 0x2, 0xff, + 0x0, 0x2, 0xff, 0x0, 0x0, 0x0, 0xa, 0xf6, + 0x0, 0x0, 0xd, 0xf7, 0x0, 0xaf, 0xa0, 0x0, + 0x0, 0x3, 0xfd, 0x0, 0x0, 0x0, 0x3f, 0xfd, + 0xdf, 0xe1, 0x0, 0x0, 0x0, 0xcf, 0x40, 0x0, + 0x0, 0x0, 0x3b, 0xfe, 0xa1, 0x0, + + /* U+0026 "&" */ + 0x0, 0x0, 0x18, 0xdf, 0xea, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0x51, 0x4e, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xf7, 0x0, 0x5, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x3f, 0xf5, 0x0, + 0x3, 0xff, 0x40, 0x0, 0x0, 0x0, 0x1f, 0xfa, + 0x0, 0x7, 0xff, 0x10, 0x0, 0x0, 0x0, 0x9, + 0xff, 0x50, 0x3f, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xf9, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xe4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x19, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xdf, 0xf9, 0x7f, 0xfd, 0x10, + 0x5, 0x20, 0x0, 0xd, 0xff, 0x50, 0x9, 0xff, + 0xb0, 0x2f, 0xf8, 0x0, 0x6f, 0xf7, 0x0, 0x0, + 0xbf, 0xf9, 0x8f, 0xf3, 0x0, 0xbf, 0xf0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xd0, 0x0, 0xcf, 0xe0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0x40, 0x0, 0xaf, + 0xf3, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x30, 0x0, + 0x4f, 0xfc, 0x0, 0x0, 0x4, 0xff, 0xff, 0xe2, + 0x0, 0xb, 0xff, 0xd5, 0x35, 0xbf, 0xfe, 0x9f, + 0xfe, 0x40, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xc2, + 0x8, 0xff, 0xb0, 0x0, 0x5, 0xbe, 0xfe, 0xb5, + 0x0, 0x0, 0x6d, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0027 "'" */ + 0xbf, 0xf1, 0xbf, 0xf1, 0xbf, 0xf1, 0xbf, 0xf0, + 0x8f, 0xe0, 0x6f, 0xb0, 0x3f, 0x80, 0x2, 0x10, + + /* U+0028 "(" */ + 0x0, 0x0, 0xc, 0xe1, 0x0, 0x0, 0x8f, 0x60, + 0x0, 0x2, 0xfe, 0x0, 0x0, 0xb, 0xf6, 0x0, + 0x0, 0x3f, 0xe0, 0x0, 0x0, 0xbf, 0x90, 0x0, + 0x1, 0xff, 0x30, 0x0, 0x6, 0xff, 0x0, 0x0, + 0xb, 0xfb, 0x0, 0x0, 0xf, 0xf8, 0x0, 0x0, + 0x1f, 0xf6, 0x0, 0x0, 0x3f, 0xf4, 0x0, 0x0, + 0x4f, 0xf3, 0x0, 0x0, 0x4f, 0xf3, 0x0, 0x0, + 0x3f, 0xf4, 0x0, 0x0, 0x1f, 0xf6, 0x0, 0x0, + 0xf, 0xf8, 0x0, 0x0, 0xb, 0xfb, 0x0, 0x0, + 0x7, 0xff, 0x0, 0x0, 0x1, 0xff, 0x40, 0x0, + 0x0, 0xbf, 0x90, 0x0, 0x0, 0x4f, 0xe0, 0x0, + 0x0, 0xb, 0xf6, 0x0, 0x0, 0x2, 0xfe, 0x0, + 0x0, 0x0, 0x8f, 0x60, 0x0, 0x0, 0xc, 0xe1, + + /* U+0029 ")" */ + 0xbf, 0x20, 0x0, 0x2, 0xfd, 0x0, 0x0, 0x9, + 0xf7, 0x0, 0x0, 0x1f, 0xf1, 0x0, 0x0, 0xaf, + 0x80, 0x0, 0x4, 0xff, 0x0, 0x0, 0xe, 0xf6, + 0x0, 0x0, 0xaf, 0xc0, 0x0, 0x6, 0xff, 0x0, + 0x0, 0x3f, 0xf4, 0x0, 0x1, 0xff, 0x60, 0x0, + 0xf, 0xf8, 0x0, 0x0, 0xef, 0x90, 0x0, 0xe, + 0xf9, 0x0, 0x0, 0xff, 0x80, 0x0, 0x1f, 0xf6, + 0x0, 0x3, 0xff, 0x40, 0x0, 0x6f, 0xf0, 0x0, + 0xa, 0xfc, 0x0, 0x0, 0xef, 0x60, 0x0, 0x4f, + 0xf0, 0x0, 0xa, 0xf8, 0x0, 0x1, 0xff, 0x10, + 0x0, 0x9f, 0x70, 0x0, 0x2f, 0xd0, 0x0, 0xb, + 0xf2, 0x0, 0x0, + + /* U+002A "*" */ + 0x0, 0x0, 0x8f, 0x60, 0x0, 0x0, 0x0, 0x7f, + 0x50, 0x0, 0x7, 0x82, 0x6f, 0x33, 0x96, 0xe, + 0xff, 0xdf, 0xdf, 0xfc, 0x3, 0x6a, 0xff, 0xea, + 0x73, 0x0, 0x5, 0xfe, 0xf4, 0x0, 0x0, 0x3f, + 0xe2, 0xff, 0x20, 0x0, 0xbf, 0x50, 0x7f, 0x90, + 0x0, 0x5, 0x0, 0x5, 0x0, + + /* U+002B "+" */ + 0x0, 0x0, 0x0, 0x56, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x50, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x25, 0x55, 0x55, 0xff, 0x85, 0x55, 0x54, 0x0, + 0x0, 0x0, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x50, + 0x0, 0x0, + + /* U+002C "," */ + 0x7d, 0xd3, 0x9f, 0xf3, 0x9f, 0xf3, 0x3, 0xf2, + 0x7, 0xf0, 0x3e, 0x90, 0x5a, 0x0, + + /* U+002D "-" */ + 0x8, 0x88, 0x88, 0x88, 0x31, 0xff, 0xff, 0xff, + 0xf7, 0x1f, 0xff, 0xff, 0xff, 0x70, + + /* U+002E "." */ + 0x6d, 0xd3, 0x8f, 0xf4, 0x8f, 0xf4, + + /* U+002F "/" */ + 0x0, 0x0, 0x5, 0xfa, 0x0, 0x0, 0xa, 0xf5, + 0x0, 0x0, 0xe, 0xf1, 0x0, 0x0, 0x3f, 0xc0, + 0x0, 0x0, 0x7f, 0x70, 0x0, 0x0, 0xcf, 0x20, + 0x0, 0x1, 0xfe, 0x0, 0x0, 0x5, 0xf9, 0x0, + 0x0, 0xa, 0xf5, 0x0, 0x0, 0xe, 0xf0, 0x0, + 0x0, 0x3f, 0xb0, 0x0, 0x0, 0x8f, 0x70, 0x0, + 0x0, 0xdf, 0x20, 0x0, 0x1, 0xfd, 0x0, 0x0, + 0x6, 0xf9, 0x0, 0x0, 0xb, 0xf4, 0x0, 0x0, + 0xf, 0xf0, 0x0, 0x0, 0x4f, 0xb0, 0x0, 0x0, + 0x9f, 0x60, 0x0, 0x0, 0xdf, 0x20, 0x0, 0x0, + + /* U+0030 "0" */ + 0x0, 0x2, 0x9d, 0xfe, 0xc6, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x2, 0xff, + 0xd5, 0x12, 0x9f, 0xf9, 0x0, 0xa, 0xfe, 0x10, + 0x0, 0x8, 0xff, 0x20, 0xf, 0xf8, 0x0, 0x0, + 0x0, 0xff, 0x80, 0x5f, 0xf3, 0x0, 0x0, 0x0, + 0xaf, 0xd0, 0x8f, 0xf0, 0x0, 0x0, 0x0, 0x7f, + 0xf0, 0xaf, 0xd0, 0x0, 0x0, 0x0, 0x5f, 0xf2, + 0xbf, 0xc0, 0x0, 0x0, 0x0, 0x4f, 0xf3, 0xcf, + 0xc0, 0x0, 0x0, 0x0, 0x4f, 0xf4, 0xcf, 0xc0, + 0x0, 0x0, 0x0, 0x4f, 0xf4, 0xbf, 0xc0, 0x0, + 0x0, 0x0, 0x4f, 0xf3, 0xaf, 0xd0, 0x0, 0x0, + 0x0, 0x5f, 0xf2, 0x8f, 0xf0, 0x0, 0x0, 0x0, + 0x7f, 0xf0, 0x5f, 0xf2, 0x0, 0x0, 0x0, 0xaf, + 0xd0, 0x1f, 0xf7, 0x0, 0x0, 0x0, 0xff, 0x80, + 0xa, 0xfe, 0x10, 0x0, 0x8, 0xff, 0x20, 0x2, + 0xff, 0xd4, 0x12, 0x9f, 0xf9, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x2, 0x9d, + 0xfe, 0xc6, 0x0, 0x0, + + /* U+0031 "1" */ + 0x0, 0x0, 0x6, 0xf7, 0x0, 0x0, 0x2f, 0xf7, + 0x0, 0x2, 0xef, 0xf7, 0x0, 0x6f, 0xff, 0xf7, + 0x3c, 0xff, 0xdf, 0xf7, 0xef, 0xfa, 0xf, 0xf7, + 0xec, 0x40, 0xf, 0xf7, 0x20, 0x0, 0xf, 0xf7, + 0x0, 0x0, 0xf, 0xf7, 0x0, 0x0, 0xf, 0xf7, + 0x0, 0x0, 0xf, 0xf7, 0x0, 0x0, 0xf, 0xf7, + 0x0, 0x0, 0xf, 0xf7, 0x0, 0x0, 0xf, 0xf7, + 0x0, 0x0, 0xf, 0xf7, 0x0, 0x0, 0xf, 0xf7, + 0x0, 0x0, 0xf, 0xf7, 0x0, 0x0, 0xf, 0xf7, + 0x0, 0x0, 0xf, 0xf7, 0x0, 0x0, 0xf, 0xf7, + + /* U+0032 "2" */ + 0x0, 0x0, 0x4a, 0xef, 0xfd, 0x81, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x9f, 0xfb, 0x41, 0x27, 0xff, 0xf2, 0x0, 0x2f, + 0xfa, 0x0, 0x0, 0x2, 0xff, 0xb0, 0x7, 0xff, + 0x10, 0x0, 0x0, 0x9, 0xff, 0x0, 0x7e, 0xe0, + 0x0, 0x0, 0x0, 0x7f, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xbf, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xdf, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xef, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xef, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfb, 0x66, 0x66, 0x66, 0x66, 0x60, 0xe, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x21, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + + /* U+0033 "3" */ + 0x0, 0x4, 0xbe, 0xfe, 0xb5, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x8, 0xff, + 0xa3, 0x13, 0x9f, 0xfa, 0x0, 0x1f, 0xfa, 0x0, + 0x0, 0x9, 0xff, 0x10, 0x6f, 0xf3, 0x0, 0x0, + 0x3, 0xff, 0x50, 0x2, 0x40, 0x0, 0x0, 0x3, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x14, 0xcf, 0xf6, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xfe, 0x40, 0x0, 0x0, + 0x0, 0xd, 0xef, 0xff, 0xd5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3d, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xf5, 0x8d, 0xc0, 0x0, 0x0, 0x0, 0x5f, + 0xf4, 0x8f, 0xf2, 0x0, 0x0, 0x0, 0x9f, 0xf1, + 0x2f, 0xfb, 0x0, 0x0, 0x4, 0xff, 0xb0, 0x9, + 0xff, 0xb4, 0x12, 0x8f, 0xfe, 0x10, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xd2, 0x0, 0x0, 0x4, 0xbe, + 0xfe, 0xb6, 0x0, 0x0, + + /* U+0034 "4" */ + 0x0, 0x0, 0x0, 0x0, 0xc, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xbe, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xe1, 0xef, 0x90, 0x0, 0x0, 0x0, 0x1e, + 0xf5, 0xe, 0xf9, 0x0, 0x0, 0x0, 0xb, 0xfa, + 0x0, 0xef, 0x90, 0x0, 0x0, 0x6, 0xfe, 0x10, + 0xe, 0xf9, 0x0, 0x0, 0x2, 0xff, 0x40, 0x0, + 0xef, 0x90, 0x0, 0x0, 0xcf, 0x90, 0x0, 0xe, + 0xf9, 0x0, 0x0, 0x8f, 0xd0, 0x0, 0x0, 0xef, + 0x90, 0x0, 0x3f, 0xf3, 0x0, 0x0, 0xe, 0xf9, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf4, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x42, 0x44, 0x44, 0x44, 0x44, 0xef, 0xa4, 0x41, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0x90, 0x0, + + /* U+0035 "5" */ + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0xef, + 0xb6, 0x66, 0x66, 0x66, 0x30, 0x1, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xfa, 0x5b, 0xef, 0xd8, 0x10, + 0x0, 0xe, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x1f, 0xff, 0xb5, 0x34, 0x9f, 0xff, 0x30, 0x3f, + 0xf8, 0x0, 0x0, 0x5, 0xff, 0xc0, 0x0, 0x20, + 0x0, 0x0, 0x0, 0x9f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xf6, 0x8d, 0xd0, 0x0, 0x0, 0x0, 0x5f, + 0xf4, 0x8f, 0xf3, 0x0, 0x0, 0x0, 0xbf, 0xf0, + 0x3f, 0xfc, 0x0, 0x0, 0x5, 0xff, 0x80, 0xa, + 0xff, 0xc4, 0x12, 0x8f, 0xfd, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x4, 0xae, + 0xfe, 0xc6, 0x0, 0x0, + + /* U+0036 "6" */ + 0x0, 0x0, 0x6b, 0xef, 0xea, 0x30, 0x0, 0x0, + 0x1c, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0xcf, + 0xf7, 0x21, 0x4d, 0xff, 0x40, 0x7, 0xff, 0x30, + 0x0, 0x1, 0xff, 0xb0, 0xe, 0xf9, 0x0, 0x0, + 0x0, 0x9e, 0xc0, 0x4f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xe0, 0x0, 0x12, 0x10, 0x0, + 0x0, 0xaf, 0xb0, 0x5d, 0xff, 0xfd, 0x50, 0x0, + 0xcf, 0xa8, 0xff, 0xff, 0xff, 0xf8, 0x0, 0xcf, + 0xef, 0xd4, 0x0, 0x4d, 0xff, 0x50, 0xdf, 0xfd, + 0x0, 0x0, 0x1, 0xef, 0xd0, 0xcf, 0xf5, 0x0, + 0x0, 0x0, 0x7f, 0xf2, 0xbf, 0xf1, 0x0, 0x0, + 0x0, 0x3f, 0xf5, 0x9f, 0xf0, 0x0, 0x0, 0x0, + 0x2f, 0xf5, 0x6f, 0xf2, 0x0, 0x0, 0x0, 0x3f, + 0xf4, 0x2f, 0xf7, 0x0, 0x0, 0x0, 0x8f, 0xf0, + 0xb, 0xff, 0x20, 0x0, 0x2, 0xff, 0xa0, 0x2, + 0xff, 0xe6, 0x11, 0x5e, 0xff, 0x10, 0x0, 0x3e, + 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x7c, + 0xff, 0xd9, 0x10, 0x0, + + /* U+0037 "7" */ + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x36, 0x66, + 0x66, 0x66, 0x67, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfc, + 0x0, 0x0, 0x0, 0x0, + + /* U+0038 "8" */ + 0x0, 0x3, 0xae, 0xff, 0xc7, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xd1, 0x0, 0x4, 0xff, + 0xd5, 0x12, 0x8f, 0xfc, 0x0, 0xb, 0xfe, 0x10, + 0x0, 0x7, 0xff, 0x40, 0xf, 0xf9, 0x0, 0x0, + 0x1, 0xff, 0x80, 0xf, 0xf9, 0x0, 0x0, 0x0, + 0xff, 0x80, 0xb, 0xfe, 0x10, 0x0, 0x6, 0xff, + 0x40, 0x3, 0xff, 0xd4, 0x12, 0x7f, 0xfb, 0x0, + 0x0, 0x3c, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x5c, 0xff, 0xff, 0xff, 0xa2, 0x0, 0x7, 0xff, + 0xa2, 0x1, 0x6e, 0xfe, 0x20, 0x2f, 0xf9, 0x0, + 0x0, 0x1, 0xef, 0xb0, 0x9f, 0xf0, 0x0, 0x0, + 0x0, 0x6f, 0xf2, 0xbf, 0xc0, 0x0, 0x0, 0x0, + 0x2f, 0xf5, 0xcf, 0xc0, 0x0, 0x0, 0x0, 0x2f, + 0xf5, 0x9f, 0xf1, 0x0, 0x0, 0x0, 0x6f, 0xf3, + 0x4f, 0xf9, 0x0, 0x0, 0x1, 0xef, 0xd0, 0xa, + 0xff, 0xb4, 0x11, 0x6e, 0xff, 0x40, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x4, 0xae, + 0xff, 0xc8, 0x10, 0x0, + + /* U+0039 "9" */ + 0x0, 0x4, 0xbe, 0xfe, 0xa4, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x8, 0xff, + 0xd4, 0x12, 0x7f, 0xfa, 0x0, 0x1f, 0xfd, 0x0, + 0x0, 0x5, 0xff, 0x40, 0x7f, 0xf3, 0x0, 0x0, + 0x0, 0xbf, 0xb0, 0xbf, 0xe0, 0x0, 0x0, 0x0, + 0x7f, 0xf0, 0xcf, 0xc0, 0x0, 0x0, 0x0, 0x5f, + 0xf2, 0xbf, 0xd0, 0x0, 0x0, 0x0, 0x7f, 0xf4, + 0x8f, 0xf2, 0x0, 0x0, 0x0, 0xbf, 0xf5, 0x3f, + 0xfc, 0x0, 0x0, 0x5, 0xff, 0xf6, 0x9, 0xff, + 0xd6, 0x34, 0x9f, 0xdf, 0xf5, 0x0, 0xbf, 0xff, + 0xff, 0xfc, 0x2f, 0xf4, 0x0, 0x5, 0xcf, 0xfc, + 0x60, 0x2f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xf0, 0x0, 0x10, 0x0, 0x0, 0x0, 0xaf, + 0xd0, 0x4f, 0xf2, 0x0, 0x0, 0x1, 0xff, 0x80, + 0x1f, 0xf8, 0x0, 0x0, 0xb, 0xff, 0x10, 0x9, + 0xff, 0x82, 0x14, 0xbf, 0xf6, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x6, 0xcf, + 0xfd, 0x92, 0x0, 0x0, + + /* U+003A ":" */ + 0x8f, 0xf4, 0x8f, 0xf4, 0x6d, 0xd3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6d, 0xd3, 0x8f, 0xf4, 0x8f, 0xf4, + + /* U+003B ";" */ + 0x9f, 0xf3, 0x9f, 0xf3, 0x7d, 0xd3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7d, 0xd3, 0x9f, 0xf3, 0x9f, 0xf3, 0x3, 0xf2, + 0x7, 0xf0, 0x3e, 0x90, 0x5a, 0x0, + + /* U+003C "<" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x48, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6d, 0xfd, 0x0, 0x0, + 0x0, 0x2, 0x9f, 0xff, 0xfa, 0x0, 0x0, 0x4, + 0xbf, 0xff, 0xf9, 0x20, 0x0, 0x6, 0xdf, 0xff, + 0xd6, 0x0, 0x0, 0x19, 0xff, 0xff, 0xa4, 0x0, + 0x0, 0x0, 0x7f, 0xfe, 0x81, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xfe, 0x71, 0x0, 0x0, 0x0, 0x0, + 0x18, 0xff, 0xff, 0xa3, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xdf, 0xff, 0xd6, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xbf, 0xff, 0xf9, 0x20, 0x0, 0x0, 0x0, + 0x2, 0x9f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7d, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x49, + + /* U+003D "=" */ + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x7f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x25, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x54, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x25, 0x55, 0x55, 0x55, 0x55, 0x55, 0x53, + + /* U+003E ">" */ + 0x56, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xf9, 0x20, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xfb, 0x40, 0x0, 0x0, 0x0, 0x1, 0x7d, 0xff, + 0xfd, 0x71, 0x0, 0x0, 0x0, 0x0, 0x4b, 0xff, + 0xff, 0x92, 0x0, 0x0, 0x0, 0x0, 0x18, 0xef, + 0xff, 0xb4, 0x0, 0x0, 0x0, 0x0, 0x5, 0xcf, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x5, 0xcf, 0xfd, + 0x0, 0x0, 0x0, 0x18, 0xef, 0xff, 0xb4, 0x0, + 0x0, 0x3a, 0xff, 0xff, 0x92, 0x0, 0x0, 0x6d, + 0xff, 0xfd, 0x70, 0x0, 0x0, 0x4f, 0xff, 0xfb, + 0x40, 0x0, 0x0, 0x0, 0x7f, 0xf9, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x57, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+003F "?" */ + 0x0, 0x4, 0xae, 0xff, 0xc8, 0x10, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x9, 0xff, + 0xc4, 0x11, 0x6e, 0xff, 0x40, 0x2f, 0xfc, 0x0, + 0x0, 0x2, 0xff, 0xd0, 0x7f, 0xf3, 0x0, 0x0, + 0x0, 0x8f, 0xf1, 0x7d, 0xe0, 0x0, 0x0, 0x0, + 0x5f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x3e, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xe2, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xfd, 0x20, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x11, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xdd, 0x20, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0x20, 0x0, 0x0, + + /* U+0040 "@" */ + 0x0, 0x0, 0x0, 0x0, 0x5, 0x9c, 0xef, 0xfe, + 0xc9, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xef, 0xfd, + 0x84, 0x20, 0x2, 0x48, 0xef, 0xfc, 0x10, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xe5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xfe, 0x10, 0x0, 0x0, 0x2, + 0xff, 0xb1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1d, 0xfd, 0x0, 0x0, 0x0, 0xcf, 0xb0, 0x0, + 0x6, 0xcf, 0xea, 0x20, 0x9f, 0xd0, 0x1d, 0xf7, + 0x0, 0x0, 0x7f, 0xd0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0x3c, 0xfa, 0x0, 0x4f, 0xf0, 0x0, 0xe, + 0xf3, 0x0, 0xc, 0xff, 0x72, 0x16, 0xfe, 0xff, + 0x60, 0x0, 0xcf, 0x50, 0x6, 0xfb, 0x0, 0x8, + 0xff, 0x40, 0x0, 0x7, 0xff, 0xf3, 0x0, 0x7, + 0xf9, 0x0, 0xbf, 0x40, 0x2, 0xff, 0x90, 0x0, + 0x0, 0xf, 0xff, 0x0, 0x0, 0x4f, 0xb0, 0xf, + 0xf0, 0x0, 0x9f, 0xf1, 0x0, 0x0, 0x0, 0xdf, + 0xc0, 0x0, 0x4, 0xfc, 0x3, 0xfc, 0x0, 0xe, + 0xfb, 0x0, 0x0, 0x0, 0xc, 0xf9, 0x0, 0x0, + 0x5f, 0xb0, 0x4f, 0xb0, 0x1, 0xff, 0x70, 0x0, + 0x0, 0x0, 0xef, 0x60, 0x0, 0x8, 0xf9, 0x6, + 0xfa, 0x0, 0x2f, 0xf5, 0x0, 0x0, 0x0, 0x2f, + 0xf2, 0x0, 0x0, 0xef, 0x40, 0x5f, 0xa0, 0x2, + 0xff, 0x60, 0x0, 0x0, 0x8, 0xff, 0x0, 0x0, + 0x6f, 0xd0, 0x4, 0xfc, 0x0, 0xf, 0xf8, 0x0, + 0x0, 0x2, 0xff, 0xc0, 0x0, 0x2f, 0xf5, 0x0, + 0x2f, 0xf0, 0x0, 0xbf, 0xe1, 0x0, 0x1, 0xdf, + 0xf9, 0x0, 0x3e, 0xfa, 0x0, 0x0, 0xef, 0x30, + 0x4, 0xff, 0xc3, 0x15, 0xdf, 0xff, 0xd6, 0x9f, + 0xfc, 0x0, 0x0, 0x9, 0xfa, 0x0, 0x8, 0xff, + 0xff, 0xfe, 0x3e, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x2f, 0xf3, 0x0, 0x5, 0xcf, 0xe9, 0x10, + 0x3d, 0xfe, 0xa4, 0x0, 0x5, 0x51, 0x0, 0x9f, + 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xfe, 0x10, 0x0, 0xcf, 0xd2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0x40, 0x0, 0x1, 0xdf, 0xf8, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5e, 0xff, 0x40, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xc7, 0x42, 0x10, 0x12, 0x59, + 0xef, 0xfd, 0x20, 0x0, 0x0, 0x0, 0x0, 0x4b, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x69, 0xce, + 0xff, 0xfe, 0xb8, 0x40, 0x0, 0x0, 0x0, + + /* U+0041 "A" */ + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xdf, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xfb, 0x8f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xf6, 0x2f, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf1, 0xd, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xc0, 0x7, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0x60, 0x1, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0x0, 0x0, 0xbf, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xfa, 0x0, 0x0, + 0x5f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf4, + 0x0, 0x0, 0xe, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xe2, 0x22, 0x22, 0x2a, 0xff, 0x40, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0xe, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xf7, 0x0, 0x0, 0x4f, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xfe, 0x0, + 0x0, 0xaf, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0x40, 0x1, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xb0, 0x7, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf2, 0xd, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf8, + + /* U+0042 "B" */ + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x93, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0xff, 0xd6, 0x66, 0x66, 0x7a, 0xff, 0xf8, 0x0, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0x0, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x30, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x6, 0xff, 0x20, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0xa, 0xfe, 0x0, + 0xff, 0xb0, 0x0, 0x0, 0x13, 0x9f, 0xf5, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x40, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, + 0xff, 0xd6, 0x66, 0x66, 0x79, 0xef, 0xfc, 0x0, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x90, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf0, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf2, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf2, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf0, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xb0, + 0xff, 0xd6, 0x66, 0x66, 0x68, 0xdf, 0xff, 0x20, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe4, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0xb7, 0x10, 0x0, + + /* U+0043 "C" */ + 0x0, 0x0, 0x1, 0x7b, 0xef, 0xfd, 0xa4, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x10, 0x0, 0x0, 0xb, 0xff, 0xfa, 0x65, + 0x58, 0xef, 0xfe, 0x20, 0x0, 0xa, 0xff, 0xb1, + 0x0, 0x0, 0x0, 0x9f, 0xfc, 0x0, 0x4, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf5, 0x0, + 0xcf, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0x80, 0x1f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x0, 0x5, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x0, 0x1, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbe, 0xa0, 0xb, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xfd, 0x0, 0x4f, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0x60, + 0x0, 0xaf, 0xfb, 0x10, 0x0, 0x0, 0x9, 0xff, + 0xc0, 0x0, 0x0, 0xcf, 0xff, 0xa6, 0x55, 0x9e, + 0xff, 0xe2, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xb1, 0x0, 0x0, 0x0, 0x0, 0x28, + 0xce, 0xff, 0xda, 0x40, 0x0, 0x0, + + /* U+0044 "D" */ + 0xcf, 0xff, 0xff, 0xff, 0xed, 0xb7, 0x10, 0x0, + 0xc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, + 0x0, 0xcf, 0xe6, 0x66, 0x66, 0x79, 0xdf, 0xff, + 0x50, 0xc, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0x20, 0xcf, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfa, 0xc, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xf1, 0xcf, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0x5c, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xf9, 0xcf, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xac, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xfb, 0xcf, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xbc, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xfa, 0xcf, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0x8c, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf5, 0xcf, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0x1c, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0x90, + 0xcf, 0xd0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf1, + 0xc, 0xfe, 0x66, 0x66, 0x67, 0x9e, 0xff, 0xf5, + 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe4, + 0x0, 0xc, 0xff, 0xff, 0xff, 0xfe, 0xda, 0x50, + 0x0, 0x0, + + /* U+0045 "E" */ + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, + 0xcf, 0xe6, 0x66, 0x66, 0x66, 0x66, 0x66, 0x40, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xe6, 0x66, 0x66, 0x66, 0x66, 0x65, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xe6, 0x66, 0x66, 0x66, 0x66, 0x66, 0x61, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + + /* U+0046 "F" */ + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xcf, 0xe6, + 0x66, 0x66, 0x66, 0x66, 0x64, 0xcf, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xe6, 0x66, 0x66, 0x66, 0x66, 0x10, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x40, 0xcf, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0047 "G" */ + 0x0, 0x0, 0x0, 0x5a, 0xde, 0xff, 0xd9, 0x40, + 0x0, 0x0, 0x0, 0x5, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xc2, 0x0, 0x0, 0x8, 0xff, 0xfc, 0x75, + 0x46, 0x8e, 0xff, 0xe1, 0x0, 0x7, 0xff, 0xd3, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xc0, 0x2, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0x40, + 0xaf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xf7, 0xf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x20, 0x4, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x30, + 0x0, 0x0, 0x3, 0x66, 0x66, 0x66, 0x66, 0x8f, + 0xf3, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0xf6, 0xff, 0x40, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xff, 0x4f, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf0, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xa, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf0, 0x2f, + 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0x0, 0x6f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x5d, + 0xff, 0xf0, 0x0, 0x7f, 0xff, 0xea, 0x77, 0x8a, + 0xef, 0xff, 0xd3, 0x0, 0x0, 0x4d, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x70, 0x0, 0x0, 0x0, 0x4, + 0x9d, 0xef, 0xed, 0xa5, 0x0, 0x0, + + /* U+0048 "H" */ + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xcf, 0xe6, 0x66, 0x66, 0x66, 0x66, 0x6c, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + + /* U+0049 "I" */ + 0x6f, 0xf3, 0x6f, 0xf3, 0x6f, 0xf3, 0x6f, 0xf3, + 0x6f, 0xf3, 0x6f, 0xf3, 0x6f, 0xf3, 0x6f, 0xf3, + 0x6f, 0xf3, 0x6f, 0xf3, 0x6f, 0xf3, 0x6f, 0xf3, + 0x6f, 0xf3, 0x6f, 0xf3, 0x6f, 0xf3, 0x6f, 0xf3, + 0x6f, 0xf3, 0x6f, 0xf3, 0x6f, 0xf3, 0x6f, 0xf3, + + /* U+004A "J" */ + 0x0, 0x0, 0x0, 0x0, 0xd, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xd, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xd, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xd, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xfd, 0x0, 0x30, + 0x0, 0x0, 0xd, 0xfd, 0x2f, 0xf4, 0x0, 0x0, + 0xe, 0xfc, 0x1f, 0xf7, 0x0, 0x0, 0xf, 0xfa, + 0xe, 0xfe, 0x10, 0x0, 0x7f, 0xf7, 0x8, 0xff, + 0xe8, 0x7a, 0xff, 0xf1, 0x0, 0xcf, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x7, 0xcf, 0xfd, 0x92, 0x0, + + /* U+004B "K" */ + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfb, + 0xf, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfa, + 0x0, 0xff, 0xb0, 0x0, 0x0, 0x0, 0xcf, 0xfa, + 0x0, 0xf, 0xfb, 0x0, 0x0, 0x0, 0xcf, 0xfa, + 0x0, 0x0, 0xff, 0xb0, 0x0, 0x0, 0xcf, 0xf9, + 0x0, 0x0, 0xf, 0xfb, 0x0, 0x0, 0xcf, 0xf8, + 0x0, 0x0, 0x0, 0xff, 0xb0, 0x0, 0xcf, 0xf8, + 0x0, 0x0, 0x0, 0xf, 0xfb, 0x0, 0xcf, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xb1, 0xcf, 0xff, + 0x20, 0x0, 0x0, 0x0, 0xf, 0xfc, 0xcf, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf5, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf5, + 0x0, 0xdf, 0xf5, 0x0, 0x0, 0x0, 0xff, 0xf5, + 0x0, 0x2, 0xff, 0xf2, 0x0, 0x0, 0xf, 0xfb, + 0x0, 0x0, 0x7, 0xff, 0xc0, 0x0, 0x0, 0xff, + 0xb0, 0x0, 0x0, 0xb, 0xff, 0x90, 0x0, 0xf, + 0xfb, 0x0, 0x0, 0x0, 0x1e, 0xff, 0x50, 0x0, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x5f, 0xfe, 0x10, + 0xf, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfc, + 0x0, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xf8, 0xf, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf4, + + /* U+004C "L" */ + 0xef, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xfd, + 0x66, 0x66, 0x66, 0x66, 0x63, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xae, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, + + /* U+004D "M" */ + 0xef, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xf3, 0xef, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf3, 0xef, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf3, 0xef, 0xdf, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xef, 0xf3, + 0xef, 0xad, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xef, + 0x9f, 0xf3, 0xef, 0xa7, 0xfe, 0x0, 0x0, 0x0, + 0x3, 0xfe, 0x5f, 0xf3, 0xef, 0xa2, 0xff, 0x40, + 0x0, 0x0, 0x9, 0xf8, 0x5f, 0xf3, 0xef, 0xa0, + 0xcf, 0x90, 0x0, 0x0, 0xe, 0xf3, 0x5f, 0xf3, + 0xef, 0xa0, 0x7f, 0xe0, 0x0, 0x0, 0x4f, 0xd0, + 0x5f, 0xf3, 0xef, 0xa0, 0x2f, 0xf4, 0x0, 0x0, + 0x9f, 0x80, 0x5f, 0xf3, 0xef, 0xa0, 0xc, 0xf9, + 0x0, 0x0, 0xef, 0x20, 0x5f, 0xf3, 0xef, 0xa0, + 0x7, 0xfe, 0x0, 0x4, 0xfc, 0x0, 0x5f, 0xf3, + 0xef, 0xa0, 0x1, 0xff, 0x40, 0xa, 0xf7, 0x0, + 0x5f, 0xf3, 0xef, 0xa0, 0x0, 0xcf, 0x90, 0xf, + 0xf1, 0x0, 0x5f, 0xf3, 0xef, 0xa0, 0x0, 0x6f, + 0xe0, 0x5f, 0xc0, 0x0, 0x5f, 0xf3, 0xef, 0xa0, + 0x0, 0x1f, 0xf4, 0xaf, 0x60, 0x0, 0x5f, 0xf3, + 0xef, 0xa0, 0x0, 0xb, 0xfa, 0xff, 0x10, 0x0, + 0x5f, 0xf3, 0xef, 0xa0, 0x0, 0x6, 0xff, 0xfb, + 0x0, 0x0, 0x5f, 0xf3, 0xef, 0xa0, 0x0, 0x1, + 0xff, 0xf6, 0x0, 0x0, 0x5f, 0xf3, 0xef, 0xa0, + 0x0, 0x0, 0xbf, 0xf0, 0x0, 0x0, 0x5f, 0xf3, + + /* U+004E "N" */ + 0xcf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xcf, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xcf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xcf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xcf, 0xdf, 0xfe, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xcf, 0xc6, 0xff, 0xa0, 0x0, 0x0, 0x8, 0xff, + 0xcf, 0xc0, 0xbf, 0xf4, 0x0, 0x0, 0x8, 0xff, + 0xcf, 0xc0, 0x2f, 0xfe, 0x10, 0x0, 0x8, 0xff, + 0xcf, 0xc0, 0x6, 0xff, 0xa0, 0x0, 0x8, 0xff, + 0xcf, 0xc0, 0x0, 0xbf, 0xf4, 0x0, 0x8, 0xff, + 0xcf, 0xc0, 0x0, 0x2f, 0xfe, 0x10, 0x8, 0xff, + 0xcf, 0xc0, 0x0, 0x6, 0xff, 0xa0, 0x8, 0xff, + 0xcf, 0xc0, 0x0, 0x0, 0xbf, 0xf5, 0x8, 0xff, + 0xcf, 0xc0, 0x0, 0x0, 0x1f, 0xfe, 0x18, 0xff, + 0xcf, 0xc0, 0x0, 0x0, 0x6, 0xff, 0xa8, 0xff, + 0xcf, 0xc0, 0x0, 0x0, 0x0, 0xbf, 0xfd, 0xff, + 0xcf, 0xc0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xcf, 0xc0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xcf, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xcf, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + + /* U+004F "O" */ + 0x0, 0x0, 0x1, 0x6b, 0xef, 0xfd, 0xa5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0xe5, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, + 0x75, 0x57, 0xcf, 0xff, 0x70, 0x0, 0x0, 0x9f, + 0xfc, 0x20, 0x0, 0x0, 0x4, 0xef, 0xf6, 0x0, + 0x4, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x2e, + 0xff, 0x10, 0xc, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0x90, 0x2f, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf0, 0x6f, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf3, + 0x8f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xf5, 0xaf, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xf7, 0xaf, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf7, 0x8f, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf5, + 0x6f, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf3, 0x1f, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf0, 0xc, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0x90, 0x5, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, 0x10, + 0x0, 0xaf, 0xfc, 0x20, 0x0, 0x0, 0x4, 0xef, + 0xf6, 0x0, 0x0, 0xb, 0xff, 0xfb, 0x65, 0x57, + 0xcf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xe5, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x7b, 0xef, 0xfd, 0xa5, 0x0, 0x0, 0x0, + + /* U+0050 "P" */ + 0xdf, 0xff, 0xff, 0xff, 0xfe, 0xda, 0x30, 0x0, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, + 0xdf, 0xe6, 0x66, 0x66, 0x67, 0xaf, 0xff, 0x70, + 0xdf, 0xd0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf0, + 0xdf, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, + 0xdf, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf6, + 0xdf, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf6, + 0xdf, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf3, + 0xdf, 0xd0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xe0, + 0xdf, 0xe6, 0x66, 0x66, 0x68, 0xcf, 0xff, 0x50, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0xdf, 0xff, 0xff, 0xff, 0xfe, 0xc8, 0x20, 0x0, + 0xdf, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0051 "Q" */ + 0x0, 0x0, 0x1, 0x7b, 0xef, 0xfd, 0xa5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0xe5, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, + 0x75, 0x57, 0xcf, 0xff, 0x80, 0x0, 0x0, 0x9f, + 0xfc, 0x20, 0x0, 0x0, 0x3, 0xef, 0xf7, 0x0, + 0x4, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x2e, + 0xff, 0x20, 0xc, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0x90, 0x2f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf0, 0x6f, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf3, + 0x9f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xf6, 0xaf, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xf7, 0xaf, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf7, 0x9f, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf5, + 0x6f, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf3, 0x2f, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xe0, 0xc, 0xff, 0x20, 0x0, + 0x0, 0x68, 0x20, 0x5, 0xff, 0x90, 0x4, 0xff, + 0xc0, 0x0, 0x0, 0xdf, 0xf8, 0x2e, 0xff, 0x10, + 0x0, 0x8f, 0xfc, 0x20, 0x0, 0x4a, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0xa, 0xff, 0xfb, 0x65, 0x57, + 0xdf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xef, 0xfc, 0x40, 0x0, 0x0, + 0x1, 0x7b, 0xef, 0xfd, 0xa5, 0x3, 0xdf, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xe6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0052 "R" */ + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xed, 0xa4, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x90, 0x0, 0xcf, 0xe3, 0x33, 0x33, 0x34, 0x59, + 0xff, 0xf6, 0x0, 0xcf, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xfe, 0x0, 0xcf, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0x20, 0xcf, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0x30, 0xcf, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0x20, 0xcf, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfd, 0x0, + 0xcf, 0xe5, 0x55, 0x55, 0x55, 0x7c, 0xff, 0xf4, + 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x40, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x50, 0x0, 0x0, 0xcf, 0xe0, 0x0, 0x13, 0xaf, + 0xfb, 0x10, 0x0, 0x0, 0xcf, 0xe0, 0x0, 0x0, + 0x7, 0xff, 0xd1, 0x0, 0x0, 0xcf, 0xe0, 0x0, + 0x0, 0x0, 0xaf, 0xfb, 0x0, 0x0, 0xcf, 0xe0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0x60, 0x0, 0xcf, + 0xe0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf1, 0x0, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfb, + 0x0, 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0x50, 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xe0, 0xcf, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xf9, + + /* U+0053 "S" */ + 0x0, 0x0, 0x5b, 0xef, 0xfe, 0xb7, 0x10, 0x0, + 0x0, 0x2, 0xdf, 0xff, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x1, 0xef, 0xfd, 0x86, 0x67, 0xbf, 0xff, + 0x60, 0x0, 0x9f, 0xf6, 0x0, 0x0, 0x0, 0x3e, + 0xff, 0x10, 0xe, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xf6, 0x0, 0xef, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0xfe, 0x70, 0xc, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfe, 0x72, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xfe, + 0xa6, 0x20, 0x0, 0x0, 0x0, 0x0, 0x4c, 0xff, + 0xff, 0xff, 0xe8, 0x10, 0x0, 0x0, 0x0, 0x1, + 0x6a, 0xdf, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x16, 0xbf, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfd, 0x7, 0xba, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf1, 0x9f, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0x25, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf0, + 0xd, 0xff, 0x91, 0x0, 0x0, 0x0, 0x7f, 0xfb, + 0x0, 0x3f, 0xff, 0xfb, 0x76, 0x79, 0xef, 0xfe, + 0x20, 0x0, 0x3d, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x20, 0x0, 0x0, 0x4, 0x9d, 0xef, 0xfd, 0xa5, + 0x0, 0x0, + + /* U+0054 "T" */ + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x76, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf7, 0x26, 0x66, 0x66, 0x6e, 0xfe, 0x66, 0x66, + 0x66, 0x30, 0x0, 0x0, 0x0, 0xcf, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xd0, 0x0, + 0x0, 0x0, + + /* U+0055 "U" */ + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xbf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xaf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xfe, + 0x7f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xf, 0xfb, + 0x3f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf7, + 0xd, 0xff, 0x70, 0x0, 0x0, 0x4, 0xff, 0xf2, + 0x4, 0xff, 0xfe, 0x97, 0x78, 0xcf, 0xff, 0x70, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x1, 0x7b, 0xef, 0xfe, 0xc7, 0x10, 0x0, + + /* U+0056 "V" */ + 0xaf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0x44, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xd0, 0xe, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xf7, 0x0, 0x8f, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0x10, 0x1, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xb0, 0x0, + 0xb, 0xff, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf4, + 0x0, 0x0, 0x5f, 0xf5, 0x0, 0x0, 0x0, 0xa, + 0xfe, 0x0, 0x0, 0x0, 0xef, 0xb0, 0x0, 0x0, + 0x1, 0xff, 0x80, 0x0, 0x0, 0x8, 0xff, 0x10, + 0x0, 0x0, 0x6f, 0xf2, 0x0, 0x0, 0x0, 0x2f, + 0xf6, 0x0, 0x0, 0xc, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xc0, 0x0, 0x2, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x6, 0xff, 0x20, 0x0, 0x8f, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xf7, 0x0, 0xe, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xd0, + 0x4, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0x30, 0xaf, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xf8, 0xf, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xe4, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xcf, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xfd, 0x0, 0x0, 0x0, 0x0, + + /* U+0057 "W" */ + 0x9f, 0xf2, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0xb, 0xfe, 0x5, 0xff, 0x50, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0x40, 0x0, 0x0, + 0x0, 0xff, 0xa0, 0x1f, 0xf9, 0x0, 0x0, 0x0, + 0x1f, 0xfe, 0xf8, 0x0, 0x0, 0x0, 0x3f, 0xf5, + 0x0, 0xcf, 0xd0, 0x0, 0x0, 0x5, 0xfe, 0x8f, + 0xd0, 0x0, 0x0, 0x7, 0xff, 0x10, 0x8, 0xff, + 0x10, 0x0, 0x0, 0xaf, 0xa4, 0xff, 0x10, 0x0, + 0x0, 0xbf, 0xd0, 0x0, 0x4f, 0xf4, 0x0, 0x0, + 0xe, 0xf5, 0xf, 0xf6, 0x0, 0x0, 0xf, 0xf8, + 0x0, 0x0, 0xff, 0x80, 0x0, 0x3, 0xff, 0x10, + 0xbf, 0xa0, 0x0, 0x3, 0xff, 0x40, 0x0, 0xb, + 0xfc, 0x0, 0x0, 0x7f, 0xc0, 0x7, 0xfe, 0x0, + 0x0, 0x7f, 0xf0, 0x0, 0x0, 0x7f, 0xf0, 0x0, + 0xc, 0xf8, 0x0, 0x2f, 0xf3, 0x0, 0xb, 0xfb, + 0x0, 0x0, 0x3, 0xff, 0x30, 0x1, 0xff, 0x30, + 0x0, 0xef, 0x80, 0x0, 0xef, 0x70, 0x0, 0x0, + 0xe, 0xf7, 0x0, 0x5f, 0xf0, 0x0, 0xa, 0xfc, + 0x0, 0x2f, 0xf2, 0x0, 0x0, 0x0, 0xaf, 0xb0, + 0xa, 0xfa, 0x0, 0x0, 0x5f, 0xf0, 0x6, 0xfe, + 0x0, 0x0, 0x0, 0x6, 0xfe, 0x0, 0xef, 0x60, + 0x0, 0x1, 0xff, 0x40, 0xaf, 0x90, 0x0, 0x0, + 0x0, 0x1f, 0xf2, 0x2f, 0xf1, 0x0, 0x0, 0xc, + 0xf8, 0xe, 0xf5, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0x56, 0xfd, 0x0, 0x0, 0x0, 0x8f, 0xc2, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x9, 0xf9, 0xaf, 0x90, + 0x0, 0x0, 0x3, 0xfe, 0x6f, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xce, 0xf4, 0x0, 0x0, 0x0, + 0xf, 0xfb, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xfb, 0x0, 0x0, 0x0, + + /* U+0058 "X" */ + 0x9, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xf9, 0x0, 0xd, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x2f, 0xfc, 0x0, 0x0, 0x3f, 0xfe, 0x10, 0x0, + 0x0, 0xc, 0xff, 0x20, 0x0, 0x0, 0x7f, 0xfa, + 0x0, 0x0, 0x9, 0xff, 0x50, 0x0, 0x0, 0x0, + 0xbf, 0xf6, 0x0, 0x5, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xf2, 0x2, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xc0, 0xcf, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xcf, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xdf, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xb1, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xe1, + 0x6, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xf4, 0x0, 0xa, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x8f, 0xf8, 0x0, 0x0, 0x1e, 0xff, 0x40, 0x0, + 0x0, 0x4f, 0xfc, 0x0, 0x0, 0x0, 0x4f, 0xfe, + 0x10, 0x0, 0x1e, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x8f, 0xfb, 0x0, 0xb, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf6, 0x8, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf2, + + /* U+0059 "Y" */ + 0x9f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0x20, 0xdf, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0x60, 0x4, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xb0, 0x0, 0x9, 0xff, 0x90, + 0x0, 0x0, 0x0, 0xef, 0xe1, 0x0, 0x0, 0xd, + 0xff, 0x40, 0x0, 0x0, 0x9f, 0xf5, 0x0, 0x0, + 0x0, 0x3f, 0xfd, 0x0, 0x0, 0x4f, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf8, 0x0, 0xd, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf3, 0x8, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xc2, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xef, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xf7, 0x0, 0x0, 0x0, 0x0, + + /* U+005A "Z" */ + 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf0, 0x2, 0x66, 0x66, 0x66, 0x66, 0x66, 0xaf, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2e, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xe6, 0x66, 0x66, 0x66, 0x66, 0x66, + 0x62, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x58, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf5, + + /* U+005B "[" */ + 0x2f, 0xff, 0xff, 0x42, 0xff, 0xff, 0xf4, 0x2f, + 0xf5, 0x0, 0x2, 0xff, 0x50, 0x0, 0x2f, 0xf5, + 0x0, 0x2, 0xff, 0x50, 0x0, 0x2f, 0xf5, 0x0, + 0x2, 0xff, 0x50, 0x0, 0x2f, 0xf5, 0x0, 0x2, + 0xff, 0x50, 0x0, 0x2f, 0xf5, 0x0, 0x2, 0xff, + 0x50, 0x0, 0x2f, 0xf5, 0x0, 0x2, 0xff, 0x50, + 0x0, 0x2f, 0xf5, 0x0, 0x2, 0xff, 0x50, 0x0, + 0x2f, 0xf5, 0x0, 0x2, 0xff, 0x50, 0x0, 0x2f, + 0xf5, 0x0, 0x2, 0xff, 0x50, 0x0, 0x2f, 0xf5, + 0x0, 0x2, 0xff, 0x50, 0x0, 0x2f, 0xf5, 0x0, + 0x2, 0xff, 0x51, 0x10, 0x2f, 0xff, 0xff, 0x42, + 0xff, 0xff, 0xf4, + + /* U+005C "\\" */ + 0xdf, 0x20, 0x0, 0x0, 0x9f, 0x60, 0x0, 0x0, + 0x4f, 0xb0, 0x0, 0x0, 0xf, 0xf0, 0x0, 0x0, + 0xb, 0xf4, 0x0, 0x0, 0x6, 0xf9, 0x0, 0x0, + 0x1, 0xfd, 0x0, 0x0, 0x0, 0xdf, 0x20, 0x0, + 0x0, 0x8f, 0x70, 0x0, 0x0, 0x3f, 0xb0, 0x0, + 0x0, 0xe, 0xf0, 0x0, 0x0, 0xa, 0xf5, 0x0, + 0x0, 0x5, 0xf9, 0x0, 0x0, 0x1, 0xfe, 0x0, + 0x0, 0x0, 0xcf, 0x20, 0x0, 0x0, 0x7f, 0x70, + 0x0, 0x0, 0x3f, 0xc0, 0x0, 0x0, 0xe, 0xf1, + 0x0, 0x0, 0xa, 0xf5, 0x0, 0x0, 0x5, 0xfa, + + /* U+005D "]" */ + 0x8f, 0xff, 0xfe, 0x8f, 0xff, 0xfe, 0x0, 0x9, + 0xfe, 0x0, 0x8, 0xfe, 0x0, 0x8, 0xfe, 0x0, + 0x8, 0xfe, 0x0, 0x8, 0xfe, 0x0, 0x8, 0xfe, + 0x0, 0x8, 0xfe, 0x0, 0x8, 0xfe, 0x0, 0x8, + 0xfe, 0x0, 0x8, 0xfe, 0x0, 0x8, 0xfe, 0x0, + 0x8, 0xfe, 0x0, 0x8, 0xfe, 0x0, 0x8, 0xfe, + 0x0, 0x8, 0xfe, 0x0, 0x8, 0xfe, 0x0, 0x8, + 0xfe, 0x0, 0x8, 0xfe, 0x0, 0x8, 0xfe, 0x0, + 0x8, 0xfe, 0x0, 0x8, 0xfe, 0x1, 0x19, 0xfe, + 0x8f, 0xff, 0xfe, 0x8f, 0xff, 0xfe, + + /* U+005E "^" */ + 0x0, 0x0, 0xa, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0xe, 0xf6, 0xff, + 0x10, 0x0, 0x0, 0x6, 0xfd, 0xc, 0xf8, 0x0, + 0x0, 0x0, 0xdf, 0x70, 0x5f, 0xe0, 0x0, 0x0, + 0x4f, 0xf1, 0x0, 0xef, 0x60, 0x0, 0xb, 0xfa, + 0x0, 0x8, 0xfd, 0x0, 0x2, 0xff, 0x40, 0x0, + 0x1f, 0xf4, 0x0, 0x9f, 0xd0, 0x0, 0x0, 0xbf, + 0xb0, 0x1f, 0xf7, 0x0, 0x0, 0x4, 0xff, 0x20, + + /* U+005F "_" */ + 0x2c, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, + 0x92, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfb, + + /* U+0060 "`" */ + 0x5d, 0xd9, 0x0, 0xa, 0xff, 0x20, 0x0, 0xcf, + 0xa0, 0x0, 0x1e, 0xf2, + + /* U+0061 "a" */ + 0x0, 0x6, 0xbe, 0xff, 0xeb, 0x50, 0x0, 0x1, + 0xdf, 0xff, 0xff, 0xff, 0xf9, 0x0, 0xc, 0xff, + 0x72, 0x11, 0x4d, 0xff, 0x40, 0x4f, 0xf7, 0x0, + 0x0, 0x2, 0xff, 0x80, 0x39, 0xb0, 0x0, 0x0, + 0x0, 0xef, 0x90, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xef, 0xa0, 0x0, 0x1, 0x58, 0xad, 0xff, 0xff, + 0xa0, 0x2, 0xbf, 0xff, 0xff, 0xfb, 0xef, 0xa0, + 0x3f, 0xff, 0xb7, 0x52, 0x0, 0xdf, 0xa0, 0xbf, + 0xf3, 0x0, 0x0, 0x0, 0xef, 0xa0, 0xef, 0xc0, + 0x0, 0x0, 0x2, 0xff, 0xa0, 0xef, 0xd0, 0x0, + 0x0, 0xb, 0xff, 0xb0, 0x9f, 0xf9, 0x10, 0x4, + 0xcf, 0xff, 0xb0, 0x1d, 0xff, 0xff, 0xff, 0xfc, + 0xbf, 0xe0, 0x0, 0x8d, 0xff, 0xeb, 0x50, 0x5f, + 0xf3, + + /* U+0062 "b" */ + 0x1f, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xf5, 0x2a, 0xef, 0xd9, + 0x20, 0x0, 0x1f, 0xf9, 0xff, 0xff, 0xff, 0xf4, + 0x0, 0x1f, 0xff, 0xf7, 0x11, 0x5e, 0xff, 0x20, + 0x1f, 0xff, 0x40, 0x0, 0x2, 0xff, 0xb0, 0x1f, + 0xfb, 0x0, 0x0, 0x0, 0x9f, 0xf1, 0x1f, 0xf6, + 0x0, 0x0, 0x0, 0x4f, 0xf5, 0x1f, 0xf3, 0x0, + 0x0, 0x0, 0x2f, 0xf6, 0x1f, 0xf2, 0x0, 0x0, + 0x0, 0xf, 0xf7, 0x1f, 0xf2, 0x0, 0x0, 0x0, + 0x1f, 0xf6, 0x1f, 0xf4, 0x0, 0x0, 0x0, 0x4f, + 0xf4, 0x1f, 0xf9, 0x0, 0x0, 0x0, 0x9f, 0xf0, + 0x1f, 0xff, 0x30, 0x0, 0x3, 0xff, 0x90, 0x1f, + 0xff, 0xe6, 0x11, 0x6e, 0xfe, 0x10, 0x1f, 0xf7, + 0xff, 0xff, 0xff, 0xe2, 0x0, 0x1f, 0xf2, 0x2a, + 0xef, 0xd8, 0x0, 0x0, + + /* U+0063 "c" */ + 0x0, 0x3, 0xae, 0xff, 0xc6, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xfc, 0x10, 0x8, 0xff, 0xb4, + 0x12, 0x8f, 0xfb, 0x1, 0xff, 0xb0, 0x0, 0x0, + 0x7f, 0xf3, 0x7f, 0xf2, 0x0, 0x0, 0x1, 0xdb, + 0x4b, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xfd, 0x0, 0x0, 0x0, 0x6, + 0x73, 0x7f, 0xf1, 0x0, 0x0, 0x0, 0xff, 0x81, + 0xff, 0x90, 0x0, 0x0, 0x7f, 0xf3, 0x8, 0xff, + 0xa3, 0x12, 0x8f, 0xfa, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x4, 0xae, 0xff, 0xb5, + 0x0, 0x0, + + /* U+0064 "d" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0x90, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0x90, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0x90, 0x0, 0x6c, 0xef, 0xc6, 0xd, 0xf9, 0x0, + 0xbf, 0xff, 0xff, 0xfa, 0xdf, 0x90, 0xaf, 0xf9, + 0x21, 0x3b, 0xff, 0xf9, 0x3f, 0xf9, 0x0, 0x0, + 0xc, 0xff, 0x99, 0xff, 0x10, 0x0, 0x0, 0x3f, + 0xf9, 0xcf, 0xc0, 0x0, 0x0, 0x0, 0xef, 0x9e, + 0xf9, 0x0, 0x0, 0x0, 0xb, 0xf9, 0xff, 0x80, + 0x0, 0x0, 0x0, 0xaf, 0x9e, 0xf9, 0x0, 0x0, + 0x0, 0xb, 0xf9, 0xcf, 0xc0, 0x0, 0x0, 0x0, + 0xdf, 0x98, 0xff, 0x10, 0x0, 0x0, 0x1f, 0xf9, + 0x2f, 0xfa, 0x0, 0x0, 0xa, 0xff, 0x90, 0x8f, + 0xfa, 0x31, 0x3b, 0xff, 0xf9, 0x0, 0x9f, 0xff, + 0xff, 0xfb, 0xbf, 0x90, 0x0, 0x4b, 0xef, 0xd7, + 0xa, 0xf9, + + /* U+0065 "e" */ + 0x0, 0x2, 0x9d, 0xff, 0xc7, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0xe3, 0x0, 0x6, 0xff, + 0xc4, 0x12, 0x6e, 0xfe, 0x10, 0x1f, 0xfb, 0x0, + 0x0, 0x1, 0xef, 0xa0, 0x7f, 0xf2, 0x0, 0x0, + 0x0, 0x7f, 0xf1, 0xbf, 0xe0, 0x0, 0x0, 0x0, + 0x3f, 0xf4, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf6, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, + 0xdf, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf3, + 0x0, 0x0, 0x0, 0x6f, 0xd3, 0x1f, 0xfc, 0x0, + 0x0, 0x1, 0xef, 0xe0, 0x7, 0xff, 0xd5, 0x11, + 0x5d, 0xff, 0x50, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x3, 0x9d, 0xff, 0xd9, 0x20, + 0x0, + + /* U+0066 "f" */ + 0x0, 0x3, 0xbe, 0xfe, 0x80, 0x2, 0xff, 0xff, + 0xf7, 0x0, 0x7f, 0xf9, 0x55, 0x20, 0x9, 0xfe, + 0x0, 0x0, 0x0, 0x9f, 0xd0, 0x0, 0xc, 0xff, + 0xff, 0xff, 0xa0, 0xbf, 0xff, 0xff, 0xfa, 0x0, + 0x9, 0xfd, 0x0, 0x0, 0x0, 0x9f, 0xd0, 0x0, + 0x0, 0x9, 0xfd, 0x0, 0x0, 0x0, 0x9f, 0xd0, + 0x0, 0x0, 0x9, 0xfd, 0x0, 0x0, 0x0, 0x9f, + 0xd0, 0x0, 0x0, 0x9, 0xfd, 0x0, 0x0, 0x0, + 0x9f, 0xd0, 0x0, 0x0, 0x9, 0xfd, 0x0, 0x0, + 0x0, 0x9f, 0xd0, 0x0, 0x0, 0x9, 0xfd, 0x0, + 0x0, 0x0, 0x9f, 0xd0, 0x0, 0x0, 0x9, 0xfd, + 0x0, 0x0, + + /* U+0067 "g" */ + 0x0, 0x0, 0x6b, 0xef, 0xd7, 0x8, 0xfc, 0x0, + 0xb, 0xff, 0xff, 0xff, 0xd9, 0xfc, 0x0, 0x9f, + 0xfa, 0x21, 0x3b, 0xff, 0xfc, 0x3, 0xff, 0x90, + 0x0, 0x0, 0xaf, 0xfc, 0x9, 0xff, 0x0, 0x0, + 0x0, 0x1f, 0xfc, 0xd, 0xfb, 0x0, 0x0, 0x0, + 0xc, 0xfc, 0xf, 0xf8, 0x0, 0x0, 0x0, 0x9, + 0xfc, 0xf, 0xf7, 0x0, 0x0, 0x0, 0x8, 0xfc, + 0xf, 0xf8, 0x0, 0x0, 0x0, 0x9, 0xfc, 0xd, + 0xfb, 0x0, 0x0, 0x0, 0xc, 0xfc, 0x9, 0xff, + 0x0, 0x0, 0x0, 0x1f, 0xfc, 0x2, 0xff, 0x90, + 0x0, 0x0, 0xaf, 0xfc, 0x0, 0x9f, 0xfa, 0x31, + 0x3a, 0xff, 0xfb, 0x0, 0xb, 0xff, 0xff, 0xff, + 0xcc, 0xfb, 0x0, 0x0, 0x5b, 0xef, 0xd7, 0xc, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xf9, + 0x6, 0x96, 0x0, 0x0, 0x0, 0xf, 0xf7, 0x6, + 0xff, 0x20, 0x0, 0x0, 0x8f, 0xf2, 0x1, 0xff, + 0xd5, 0x21, 0x39, 0xff, 0x90, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x2, 0x9d, 0xff, + 0xda, 0x40, 0x0, + + /* U+0068 "h" */ + 0x1f, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0x51, 0x8d, 0xff, 0xc5, 0x0, 0x1f, + 0xf8, 0xef, 0xff, 0xff, 0xf9, 0x1, 0xff, 0xff, + 0x94, 0x36, 0xef, 0xf2, 0x1f, 0xff, 0x40, 0x0, + 0x4, 0xff, 0x71, 0xff, 0xb0, 0x0, 0x0, 0xe, + 0xfa, 0x1f, 0xf7, 0x0, 0x0, 0x0, 0xcf, 0xb1, + 0xff, 0x50, 0x0, 0x0, 0xc, 0xfb, 0x1f, 0xf5, + 0x0, 0x0, 0x0, 0xcf, 0xb1, 0xff, 0x50, 0x0, + 0x0, 0xc, 0xfb, 0x1f, 0xf5, 0x0, 0x0, 0x0, + 0xcf, 0xb1, 0xff, 0x50, 0x0, 0x0, 0xc, 0xfb, + 0x1f, 0xf5, 0x0, 0x0, 0x0, 0xcf, 0xb1, 0xff, + 0x50, 0x0, 0x0, 0xc, 0xfb, 0x1f, 0xf5, 0x0, + 0x0, 0x0, 0xcf, 0xb1, 0xff, 0x50, 0x0, 0x0, + 0xc, 0xfb, + + /* U+0069 "i" */ + 0x2f, 0xf5, 0x2f, 0xf5, 0x1d, 0xd4, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xf5, 0x2f, 0xf5, 0x2f, 0xf5, + 0x2f, 0xf5, 0x2f, 0xf5, 0x2f, 0xf5, 0x2f, 0xf5, + 0x2f, 0xf5, 0x2f, 0xf5, 0x2f, 0xf5, 0x2f, 0xf5, + 0x2f, 0xf5, 0x2f, 0xf5, 0x2f, 0xf5, 0x2f, 0xf5, + + /* U+006A "j" */ + 0x0, 0x1, 0xff, 0x50, 0x0, 0x1f, 0xf5, 0x0, + 0x1, 0xee, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xf5, 0x0, 0x1, 0xff, + 0x50, 0x0, 0x1f, 0xf5, 0x0, 0x1, 0xff, 0x50, + 0x0, 0x1f, 0xf5, 0x0, 0x1, 0xff, 0x50, 0x0, + 0x1f, 0xf5, 0x0, 0x1, 0xff, 0x50, 0x0, 0x1f, + 0xf5, 0x0, 0x1, 0xff, 0x50, 0x0, 0x1f, 0xf5, + 0x0, 0x1, 0xff, 0x50, 0x0, 0x1f, 0xf5, 0x0, + 0x1, 0xff, 0x50, 0x0, 0x1f, 0xf5, 0x0, 0x1, + 0xff, 0x50, 0x0, 0x2f, 0xf5, 0x0, 0x3, 0xff, + 0x30, 0x43, 0xbf, 0xf0, 0xf, 0xff, 0xfa, 0x1, + 0xef, 0xe9, 0x10, + + /* U+006B "k" */ + 0x2f, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0x50, 0x0, 0x5, 0xff, 0xc0, 0x2f, + 0xf5, 0x0, 0x4, 0xff, 0xc0, 0x2, 0xff, 0x50, + 0x4, 0xff, 0xc0, 0x0, 0x2f, 0xf5, 0x3, 0xff, + 0xc0, 0x0, 0x2, 0xff, 0x53, 0xff, 0xc0, 0x0, + 0x0, 0x2f, 0xf7, 0xef, 0xf0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x2f, 0xff, + 0xcd, 0xfe, 0x10, 0x0, 0x2, 0xff, 0xc1, 0x3f, + 0xfa, 0x0, 0x0, 0x2f, 0xf5, 0x0, 0x9f, 0xf5, + 0x0, 0x2, 0xff, 0x50, 0x0, 0xef, 0xe1, 0x0, + 0x2f, 0xf5, 0x0, 0x5, 0xff, 0x90, 0x2, 0xff, + 0x50, 0x0, 0xb, 0xff, 0x40, 0x2f, 0xf5, 0x0, + 0x0, 0x1f, 0xfd, 0x2, 0xff, 0x50, 0x0, 0x0, + 0x7f, 0xf9, + + /* U+006C "l" */ + 0x2f, 0xf5, 0x2f, 0xf5, 0x2f, 0xf5, 0x2f, 0xf5, + 0x2f, 0xf5, 0x2f, 0xf5, 0x2f, 0xf5, 0x2f, 0xf5, + 0x2f, 0xf5, 0x2f, 0xf5, 0x2f, 0xf5, 0x2f, 0xf5, + 0x2f, 0xf5, 0x2f, 0xf5, 0x2f, 0xf5, 0x2f, 0xf5, + 0x2f, 0xf5, 0x2f, 0xf5, 0x2f, 0xf5, 0x2f, 0xf5, + + /* U+006D "m" */ + 0x2f, 0xf0, 0x29, 0xef, 0xe9, 0x10, 0x5, 0xce, + 0xfc, 0x60, 0x2, 0xff, 0x4f, 0xff, 0xff, 0xfd, + 0x8, 0xff, 0xff, 0xff, 0x80, 0x2f, 0xfe, 0xf7, + 0x34, 0xbf, 0xfc, 0xfb, 0x43, 0x5e, 0xff, 0x12, + 0xff, 0xf2, 0x0, 0x0, 0xef, 0xfb, 0x0, 0x0, + 0x4f, 0xf5, 0x2f, 0xfa, 0x0, 0x0, 0xa, 0xff, + 0x30, 0x0, 0x0, 0xff, 0x72, 0xff, 0x60, 0x0, + 0x0, 0x8f, 0xf0, 0x0, 0x0, 0xf, 0xf8, 0x2f, + 0xf5, 0x0, 0x0, 0x8, 0xfe, 0x0, 0x0, 0x0, + 0xff, 0x82, 0xff, 0x40, 0x0, 0x0, 0x8f, 0xe0, + 0x0, 0x0, 0xf, 0xf8, 0x2f, 0xf4, 0x0, 0x0, + 0x8, 0xfe, 0x0, 0x0, 0x0, 0xff, 0x82, 0xff, + 0x40, 0x0, 0x0, 0x8f, 0xe0, 0x0, 0x0, 0xf, + 0xf8, 0x2f, 0xf4, 0x0, 0x0, 0x8, 0xfe, 0x0, + 0x0, 0x0, 0xff, 0x82, 0xff, 0x40, 0x0, 0x0, + 0x8f, 0xe0, 0x0, 0x0, 0xf, 0xf8, 0x2f, 0xf4, + 0x0, 0x0, 0x8, 0xfe, 0x0, 0x0, 0x0, 0xff, + 0x82, 0xff, 0x40, 0x0, 0x0, 0x8f, 0xe0, 0x0, + 0x0, 0xf, 0xf8, 0x2f, 0xf4, 0x0, 0x0, 0x8, + 0xfe, 0x0, 0x0, 0x0, 0xff, 0x80, + + /* U+006E "n" */ + 0x1f, 0xf1, 0x18, 0xdf, 0xeb, 0x40, 0x1, 0xff, + 0x4e, 0xff, 0xff, 0xff, 0x80, 0x1f, 0xfe, 0xf8, + 0x33, 0x6f, 0xff, 0x31, 0xff, 0xf4, 0x0, 0x0, + 0x4f, 0xf8, 0x1f, 0xfb, 0x0, 0x0, 0x0, 0xef, + 0xa1, 0xff, 0x70, 0x0, 0x0, 0xc, 0xfb, 0x1f, + 0xf6, 0x0, 0x0, 0x0, 0xcf, 0xb1, 0xff, 0x50, + 0x0, 0x0, 0xc, 0xfb, 0x1f, 0xf5, 0x0, 0x0, + 0x0, 0xcf, 0xb1, 0xff, 0x50, 0x0, 0x0, 0xc, + 0xfb, 0x1f, 0xf5, 0x0, 0x0, 0x0, 0xcf, 0xb1, + 0xff, 0x50, 0x0, 0x0, 0xc, 0xfb, 0x1f, 0xf5, + 0x0, 0x0, 0x0, 0xcf, 0xb1, 0xff, 0x50, 0x0, + 0x0, 0xc, 0xfb, 0x1f, 0xf5, 0x0, 0x0, 0x0, + 0xcf, 0xb0, + + /* U+006F "o" */ + 0x0, 0x0, 0x39, 0xdf, 0xfc, 0x81, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0xe3, 0x0, 0x0, + 0x9f, 0xfc, 0x41, 0x26, 0xef, 0xf2, 0x0, 0x3f, + 0xfb, 0x0, 0x0, 0x2, 0xff, 0xc0, 0x9, 0xff, + 0x10, 0x0, 0x0, 0x8, 0xff, 0x20, 0xdf, 0xb0, + 0x0, 0x0, 0x0, 0x2f, 0xf6, 0xf, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0xff, 0x80, 0xff, 0x80, 0x0, + 0x0, 0x0, 0xf, 0xf9, 0xf, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0xff, 0x80, 0xdf, 0xb0, 0x0, 0x0, + 0x0, 0x2f, 0xf6, 0x9, 0xff, 0x10, 0x0, 0x0, + 0x8, 0xff, 0x20, 0x3f, 0xfa, 0x0, 0x0, 0x2, + 0xff, 0xb0, 0x0, 0x9f, 0xfc, 0x41, 0x26, 0xef, + 0xf2, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xe4, + 0x0, 0x0, 0x0, 0x3a, 0xef, 0xfc, 0x81, 0x0, + 0x0, + + /* U+0070 "p" */ + 0x1f, 0xf2, 0x2a, 0xef, 0xe9, 0x20, 0x0, 0x1f, + 0xf6, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x1f, 0xff, + 0xf6, 0x0, 0x4d, 0xff, 0x20, 0x1f, 0xff, 0x40, + 0x0, 0x1, 0xff, 0xb0, 0x1f, 0xfb, 0x0, 0x0, + 0x0, 0x8f, 0xf1, 0x1f, 0xf6, 0x0, 0x0, 0x0, + 0x3f, 0xf5, 0x1f, 0xf3, 0x0, 0x0, 0x0, 0x1f, + 0xf7, 0x1f, 0xf2, 0x0, 0x0, 0x0, 0xf, 0xf7, + 0x1f, 0xf2, 0x0, 0x0, 0x0, 0x1f, 0xf6, 0x1f, + 0xf5, 0x0, 0x0, 0x0, 0x3f, 0xf4, 0x1f, 0xf9, + 0x0, 0x0, 0x0, 0x9f, 0xf0, 0x1f, 0xff, 0x20, + 0x0, 0x3, 0xff, 0x90, 0x1f, 0xff, 0xe6, 0x11, + 0x6e, 0xfe, 0x10, 0x1f, 0xfa, 0xff, 0xff, 0xff, + 0xe2, 0x0, 0x1f, 0xf5, 0x3b, 0xef, 0xd8, 0x10, + 0x0, 0x1f, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+0071 "q" */ + 0x0, 0x6, 0xce, 0xfc, 0x60, 0x9f, 0xa0, 0xb, + 0xff, 0xff, 0xff, 0xb9, 0xfa, 0x9, 0xff, 0x81, + 0x2, 0xaf, 0xff, 0xa3, 0xff, 0x80, 0x0, 0x0, + 0xbf, 0xfa, 0x8f, 0xf1, 0x0, 0x0, 0x3, 0xff, + 0xac, 0xfc, 0x0, 0x0, 0x0, 0xd, 0xfa, 0xef, + 0x90, 0x0, 0x0, 0x0, 0xaf, 0xae, 0xf9, 0x0, + 0x0, 0x0, 0x9, 0xfa, 0xef, 0xa0, 0x0, 0x0, + 0x0, 0xaf, 0xab, 0xfc, 0x0, 0x0, 0x0, 0xc, + 0xfa, 0x7f, 0xf2, 0x0, 0x0, 0x1, 0xff, 0xa1, + 0xff, 0xb0, 0x0, 0x0, 0xaf, 0xfa, 0x6, 0xff, + 0xb3, 0x13, 0xaf, 0xff, 0xa0, 0x8, 0xff, 0xff, + 0xff, 0xcd, 0xfa, 0x0, 0x4, 0xbe, 0xfd, 0x70, + 0xdf, 0xa0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xa0, + + /* U+0072 "r" */ + 0x3f, 0xf0, 0x5d, 0xfd, 0x53, 0xff, 0x5f, 0xff, + 0xf6, 0x3f, 0xfe, 0xfa, 0xae, 0x13, 0xff, 0xf3, + 0x0, 0x0, 0x3f, 0xfa, 0x0, 0x0, 0x3, 0xff, + 0x60, 0x0, 0x0, 0x3f, 0xf5, 0x0, 0x0, 0x3, + 0xff, 0x40, 0x0, 0x0, 0x3f, 0xf4, 0x0, 0x0, + 0x3, 0xff, 0x40, 0x0, 0x0, 0x3f, 0xf4, 0x0, + 0x0, 0x3, 0xff, 0x40, 0x0, 0x0, 0x3f, 0xf4, + 0x0, 0x0, 0x3, 0xff, 0x40, 0x0, 0x0, 0x3f, + 0xf4, 0x0, 0x0, 0x0, + + /* U+0073 "s" */ + 0x0, 0x5, 0xbe, 0xfe, 0xc7, 0x10, 0x0, 0xa, + 0xff, 0xff, 0xff, 0xff, 0x30, 0x5, 0xff, 0x93, + 0x12, 0x6f, 0xfe, 0x0, 0xaf, 0xc0, 0x0, 0x0, + 0x5f, 0xf3, 0xa, 0xfd, 0x0, 0x0, 0x0, 0x42, + 0x0, 0x6f, 0xfd, 0x72, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xfd, 0x94, 0x0, 0x0, 0x0, 0x6d, + 0xff, 0xff, 0xfe, 0x60, 0x0, 0x0, 0x1, 0x6a, + 0xef, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xfc, 0xb, 0xe7, 0x0, 0x0, 0x0, 0xaf, 0xe0, + 0xdf, 0xd0, 0x0, 0x0, 0xd, 0xfc, 0x5, 0xff, + 0xc4, 0x11, 0x4b, 0xff, 0x50, 0x8, 0xff, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x3, 0xad, 0xff, 0xea, + 0x30, 0x0, + + /* U+0074 "t" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xa0, 0x0, + 0x0, 0xaf, 0xb0, 0x0, 0x0, 0xcf, 0xb0, 0x0, + 0x0, 0xcf, 0xb0, 0x0, 0x0, 0xcf, 0xb0, 0x0, + 0x8f, 0xff, 0xff, 0xf2, 0x8f, 0xff, 0xff, 0xf2, + 0x0, 0xcf, 0xb0, 0x0, 0x0, 0xcf, 0xb0, 0x0, + 0x0, 0xcf, 0xb0, 0x0, 0x0, 0xcf, 0xb0, 0x0, + 0x0, 0xcf, 0xb0, 0x0, 0x0, 0xcf, 0xb0, 0x0, + 0x0, 0xcf, 0xb0, 0x0, 0x0, 0xcf, 0xb0, 0x0, + 0x0, 0xbf, 0xb0, 0x0, 0x0, 0xbf, 0xc0, 0x0, + 0x0, 0xaf, 0xf7, 0x51, 0x0, 0x5f, 0xff, 0xf5, + 0x0, 0x7, 0xdf, 0xe6, + + /* U+0075 "u" */ + 0x2f, 0xf5, 0x0, 0x0, 0x0, 0xdf, 0xa2, 0xff, + 0x50, 0x0, 0x0, 0xd, 0xfa, 0x2f, 0xf5, 0x0, + 0x0, 0x0, 0xdf, 0xa2, 0xff, 0x50, 0x0, 0x0, + 0xd, 0xfa, 0x2f, 0xf5, 0x0, 0x0, 0x0, 0xdf, + 0xa2, 0xff, 0x50, 0x0, 0x0, 0xd, 0xfa, 0x2f, + 0xf5, 0x0, 0x0, 0x0, 0xdf, 0xa2, 0xff, 0x50, + 0x0, 0x0, 0xd, 0xfa, 0x2f, 0xf5, 0x0, 0x0, + 0x0, 0xef, 0xa2, 0xff, 0x50, 0x0, 0x0, 0xf, + 0xfa, 0x1f, 0xf6, 0x0, 0x0, 0x3, 0xff, 0xa0, + 0xef, 0xc0, 0x0, 0x0, 0xbf, 0xfa, 0xa, 0xff, + 0xb4, 0x25, 0xcf, 0xef, 0xa0, 0x1d, 0xff, 0xff, + 0xff, 0x89, 0xfa, 0x0, 0x18, 0xdf, 0xeb, 0x40, + 0x9f, 0xa0, + + /* U+0076 "v" */ + 0x7f, 0xf2, 0x0, 0x0, 0x0, 0x1f, 0xf7, 0x1f, + 0xf7, 0x0, 0x0, 0x0, 0x6f, 0xf2, 0xb, 0xfd, + 0x0, 0x0, 0x0, 0xbf, 0xc0, 0x5, 0xff, 0x20, + 0x0, 0x1, 0xff, 0x60, 0x0, 0xff, 0x80, 0x0, + 0x7, 0xff, 0x0, 0x0, 0x9f, 0xd0, 0x0, 0xc, + 0xfa, 0x0, 0x0, 0x4f, 0xf3, 0x0, 0x2f, 0xf4, + 0x0, 0x0, 0xe, 0xf9, 0x0, 0x8f, 0xe0, 0x0, + 0x0, 0x8, 0xfe, 0x0, 0xdf, 0x80, 0x0, 0x0, + 0x2, 0xff, 0x33, 0xff, 0x30, 0x0, 0x0, 0x0, + 0xcf, 0x88, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xdd, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0x50, 0x0, + 0x0, + + /* U+0077 "w" */ + 0xbf, 0xd0, 0x0, 0x0, 0x3f, 0xf8, 0x0, 0x0, + 0x7, 0xfe, 0x6, 0xff, 0x10, 0x0, 0x7, 0xff, + 0xd0, 0x0, 0x0, 0xcf, 0x90, 0x1f, 0xf5, 0x0, + 0x0, 0xbf, 0xff, 0x10, 0x0, 0x1f, 0xf4, 0x0, + 0xdf, 0x90, 0x0, 0xf, 0xfe, 0xf5, 0x0, 0x5, + 0xff, 0x0, 0x8, 0xfe, 0x0, 0x4, 0xfd, 0xaf, + 0x90, 0x0, 0xaf, 0xb0, 0x0, 0x3f, 0xf2, 0x0, + 0x8f, 0x97, 0xfd, 0x0, 0xe, 0xf6, 0x0, 0x0, + 0xef, 0x60, 0xc, 0xf5, 0x3f, 0xf1, 0x3, 0xff, + 0x10, 0x0, 0xa, 0xfa, 0x1, 0xff, 0x10, 0xff, + 0x50, 0x7f, 0xc0, 0x0, 0x0, 0x5f, 0xe0, 0x5f, + 0xc0, 0xb, 0xf9, 0xc, 0xf7, 0x0, 0x0, 0x1, + 0xff, 0x39, 0xf8, 0x0, 0x7f, 0xd1, 0xff, 0x20, + 0x0, 0x0, 0xc, 0xf7, 0xdf, 0x40, 0x3, 0xff, + 0x6f, 0xe0, 0x0, 0x0, 0x0, 0x7f, 0xdf, 0xf0, + 0x0, 0xe, 0xfe, 0xf9, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xfc, 0x0, 0x0, 0xaf, 0xff, 0x40, 0x0, + 0x0, 0x0, 0xd, 0xff, 0x80, 0x0, 0x6, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x0, + 0x0, 0x2f, 0xfa, 0x0, 0x0, 0x0, + + /* U+0078 "x" */ + 0x1f, 0xfe, 0x10, 0x0, 0x0, 0xdf, 0xe1, 0x5, + 0xff, 0x90, 0x0, 0x9, 0xff, 0x50, 0x0, 0xbf, + 0xf4, 0x0, 0x4f, 0xfa, 0x0, 0x0, 0x1e, 0xfd, + 0x0, 0xef, 0xd0, 0x0, 0x0, 0x5, 0xff, 0x89, + 0xff, 0x30, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xbb, 0xff, 0x10, 0x0, 0x0, 0xb, + 0xff, 0x22, 0xff, 0xb0, 0x0, 0x0, 0x6f, 0xf7, + 0x0, 0x7f, 0xf6, 0x0, 0x2, 0xff, 0xc0, 0x0, + 0xc, 0xff, 0x20, 0xc, 0xff, 0x20, 0x0, 0x3, + 0xff, 0xc0, 0x7f, 0xf8, 0x0, 0x0, 0x0, 0x8f, + 0xf7, + + /* U+0079 "y" */ + 0x5f, 0xf4, 0x0, 0x0, 0x0, 0xe, 0xf9, 0xf, + 0xfa, 0x0, 0x0, 0x0, 0x3f, 0xf3, 0xa, 0xff, + 0x0, 0x0, 0x0, 0x9f, 0xd0, 0x4, 0xff, 0x50, + 0x0, 0x0, 0xef, 0x70, 0x0, 0xef, 0xa0, 0x0, + 0x4, 0xff, 0x10, 0x0, 0x8f, 0xf0, 0x0, 0xa, + 0xfc, 0x0, 0x0, 0x2f, 0xf5, 0x0, 0xf, 0xf6, + 0x0, 0x0, 0xc, 0xfb, 0x0, 0x6f, 0xf0, 0x0, + 0x0, 0x6, 0xff, 0x10, 0xbf, 0xa0, 0x0, 0x0, + 0x1, 0xff, 0x50, 0xff, 0x40, 0x0, 0x0, 0x0, + 0xbf, 0xa5, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xfa, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xf4, 0x0, 0x0, 0x0, 0x4, 0x78, + 0xef, 0xd0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x3, 0xef, 0xd4, 0x0, + 0x0, 0x0, 0x0, + + /* U+007A "z" */ + 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0xe, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x2e, 0xfe, 0x21, 0x22, + 0x22, 0x22, 0x20, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf6, + + /* U+007B "{" */ + 0x0, 0x0, 0x8, 0xdf, 0xb0, 0x0, 0x9, 0xff, + 0xfb, 0x0, 0x1, 0xff, 0xa3, 0x10, 0x0, 0x3f, + 0xf1, 0x0, 0x0, 0x5, 0xff, 0x0, 0x0, 0x0, + 0x5f, 0xe0, 0x0, 0x0, 0x6, 0xfe, 0x0, 0x0, + 0x0, 0x6f, 0xe0, 0x0, 0x0, 0x7, 0xfd, 0x0, + 0x0, 0x0, 0x9f, 0xb0, 0x0, 0x0, 0xe, 0xf7, + 0x0, 0x0, 0x6c, 0xfd, 0x0, 0x0, 0x3f, 0xfa, + 0x10, 0x0, 0x3, 0xff, 0xd3, 0x0, 0x0, 0x1, + 0x8f, 0xe1, 0x0, 0x0, 0x0, 0xdf, 0x80, 0x0, + 0x0, 0x9, 0xfc, 0x0, 0x0, 0x0, 0x7f, 0xd0, + 0x0, 0x0, 0x6, 0xfe, 0x0, 0x0, 0x0, 0x5f, + 0xe0, 0x0, 0x0, 0x5, 0xff, 0x0, 0x0, 0x0, + 0x5f, 0xf0, 0x0, 0x0, 0x3, 0xff, 0x0, 0x0, + 0x0, 0x1f, 0xfa, 0x31, 0x0, 0x0, 0x9f, 0xff, + 0xb0, 0x0, 0x0, 0x8e, 0xfb, + + /* U+007C "|" */ + 0x6f, 0xb6, 0xfb, 0x6f, 0xb6, 0xfb, 0x6f, 0xb6, + 0xfb, 0x6f, 0xb6, 0xfb, 0x6f, 0xb6, 0xfb, 0x6f, + 0xb6, 0xfb, 0x6f, 0xb6, 0xfb, 0x6f, 0xb6, 0xfb, + 0x6f, 0xb6, 0xfb, 0x6f, 0xb6, 0xfb, 0x6f, 0xb6, + 0xfb, 0x6f, 0xb6, 0xfb, 0x6f, 0xb6, 0xfb, + + /* U+007D "}" */ + 0x5f, 0xeb, 0x20, 0x0, 0x5, 0xff, 0xfe, 0x0, + 0x0, 0x3, 0x6f, 0xf6, 0x0, 0x0, 0x0, 0xbf, + 0x90, 0x0, 0x0, 0x9, 0xfa, 0x0, 0x0, 0x0, + 0x9f, 0xb0, 0x0, 0x0, 0x9, 0xfb, 0x0, 0x0, + 0x0, 0x8f, 0xc0, 0x0, 0x0, 0x8, 0xfd, 0x0, + 0x0, 0x0, 0x5f, 0xf0, 0x0, 0x0, 0x1, 0xff, + 0x40, 0x0, 0x0, 0x8, 0xfe, 0x72, 0x0, 0x0, + 0x6, 0xff, 0x90, 0x0, 0x0, 0xbf, 0xf9, 0x0, + 0x0, 0xbf, 0xc2, 0x0, 0x0, 0x3f, 0xf2, 0x0, + 0x0, 0x6, 0xfe, 0x0, 0x0, 0x0, 0x8f, 0xc0, + 0x0, 0x0, 0x8, 0xfc, 0x0, 0x0, 0x0, 0x9f, + 0xb0, 0x0, 0x0, 0x9, 0xfb, 0x0, 0x0, 0x0, + 0x9f, 0xa0, 0x0, 0x0, 0xb, 0xf9, 0x0, 0x0, + 0x37, 0xff, 0x60, 0x0, 0x5f, 0xff, 0xe0, 0x0, + 0x5, 0xfe, 0xa2, 0x0, 0x0, + + /* U+007E "~" */ + 0x0, 0x58, 0x85, 0x10, 0x0, 0x0, 0x1, 0x13, + 0xef, 0xff, 0xff, 0xa3, 0x0, 0x3, 0xd2, 0xcf, + 0xff, 0xff, 0xff, 0xfd, 0xac, 0xff, 0x2d, 0xc4, + 0x1, 0x6d, 0xff, 0xff, 0xff, 0xd1, 0x80, 0x0, + 0x0, 0x4, 0xad, 0xfd, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00A0 " " */ + + /* U+00A3 "£" */ + 0x0, 0x0, 0x17, 0xcf, 0xfe, 0xa3, 0x0, 0x0, + 0x0, 0x3e, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x1e, 0xff, 0x72, 0x14, 0xdf, 0xf6, 0x0, 0x9, + 0xff, 0x40, 0x0, 0x0, 0xdf, 0xe0, 0x0, 0xdf, + 0xd0, 0x0, 0x0, 0x6, 0xff, 0x30, 0xe, 0xfb, + 0x0, 0x0, 0x0, 0x14, 0x20, 0x0, 0xdf, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xef, 0x40, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xfe, 0xff, 0xec, 0x97, 0x68, 0xc3, 0x3f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0xc8, + 0x41, 0x1, 0x47, 0xbe, 0xfe, 0xa5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00A4 "¤" */ + 0xa, 0x20, 0x0, 0x0, 0x0, 0x7, 0x50, 0xaf, + 0xe3, 0x7c, 0xfe, 0xb4, 0x7f, 0xf3, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb0, 0x4, 0xff, 0xf8, + 0x45, 0xcf, 0xfc, 0x0, 0x6, 0xff, 0x30, 0x0, + 0xa, 0xff, 0x0, 0xc, 0xf8, 0x0, 0x0, 0x0, + 0xff, 0x50, 0xe, 0xf4, 0x0, 0x0, 0x0, 0xbf, + 0x80, 0xe, 0xf4, 0x0, 0x0, 0x0, 0xbf, 0x80, + 0xc, 0xf8, 0x0, 0x0, 0x0, 0xff, 0x50, 0x6, + 0xff, 0x30, 0x0, 0xa, 0xff, 0x0, 0x4, 0xff, + 0xf8, 0x45, 0xcf, 0xfc, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb0, 0xaf, 0xe3, 0x7c, 0xfe, + 0xb3, 0x7f, 0xf3, 0xa, 0x20, 0x0, 0x0, 0x0, + 0x7, 0x50, + + /* U+00A5 "¥" */ + 0xbf, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf4, + 0x2f, 0xf9, 0x0, 0x0, 0x0, 0x2, 0xff, 0xb0, + 0x9, 0xff, 0x20, 0x0, 0x0, 0xb, 0xff, 0x20, + 0x1, 0xff, 0xa0, 0x0, 0x0, 0x3f, 0xf9, 0x0, + 0x0, 0x7f, 0xf3, 0x0, 0x0, 0xcf, 0xf1, 0x0, + 0x0, 0xe, 0xfc, 0x0, 0x4, 0xff, 0x70, 0x0, + 0x0, 0x5, 0xff, 0x50, 0xc, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xd0, 0x5f, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xf5, 0xdf, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xfe, 0xff, 0x50, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x6f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xf0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, + 0x1e, 0xee, 0xee, 0xff, 0xfe, 0xee, 0xee, 0x90, + 0x0, 0x0, 0x0, 0x6f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xf0, 0x0, 0x0, 0x0, + + /* U+00A6 "¦" */ + 0x6f, 0xb6, 0xfb, 0x6f, 0xb6, 0xfb, 0x6f, 0xb6, + 0xfb, 0x6f, 0xb6, 0xfb, 0x6f, 0xb6, 0xfb, 0x6e, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xea, + 0x6f, 0xb6, 0xfb, 0x6f, 0xb6, 0xfb, 0x6f, 0xb6, + 0xfb, 0x6f, 0xb6, 0xfb, 0x6f, 0xb6, 0xfb, + + /* U+00A7 "§" */ + 0x0, 0x3, 0xae, 0xfe, 0xb6, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x1, 0xff, + 0xd4, 0x12, 0xaf, 0xf7, 0x0, 0x6, 0xff, 0x10, + 0x0, 0xd, 0xfe, 0x0, 0x7, 0xff, 0x0, 0x0, + 0x7, 0xec, 0x10, 0x4, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xd3, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xcf, 0xff, 0x90, 0x0, 0x0, 0x3f, + 0xf4, 0x5, 0xef, 0xfe, 0x40, 0x0, 0xaf, 0x90, + 0x0, 0x1a, 0xff, 0xf8, 0x0, 0xdf, 0x70, 0x0, + 0x0, 0x5e, 0xff, 0x80, 0xbf, 0xc0, 0x0, 0x0, + 0x2, 0xef, 0xf1, 0x5f, 0xf9, 0x0, 0x0, 0x0, + 0x4f, 0xf4, 0x8, 0xff, 0xc3, 0x0, 0x0, 0xf, + 0xf4, 0x0, 0x6f, 0xff, 0x90, 0x0, 0x4f, 0xe0, + 0x0, 0x2, 0xcf, 0xfe, 0x43, 0xef, 0x40, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xb1, 0x0, 0x0, 0x0, + 0x0, 0x1b, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xfc, 0x0, 0x0, 0x11, 0x0, 0x0, + 0x7, 0xff, 0x30, 0xd, 0xfb, 0x0, 0x0, 0x2, + 0xff, 0x50, 0xa, 0xff, 0x30, 0x0, 0x5, 0xff, + 0x40, 0x2, 0xff, 0xe6, 0x22, 0x7f, 0xfd, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xe3, 0x0, 0x0, + 0x2, 0x9d, 0xff, 0xd8, 0x10, 0x0, + + /* U+00A8 "¨" */ + 0x2d, 0xd5, 0x0, 0xdd, 0x62, 0xff, 0x60, 0x1f, + 0xf8, 0x2f, 0xf6, 0x1, 0xff, 0x80, + + /* U+00A9 "©" */ + 0x0, 0x0, 0x0, 0x4, 0x8a, 0xb9, 0x73, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7e, 0xff, 0xff, + 0xff, 0xfd, 0x40, 0x0, 0x0, 0x0, 0x2, 0xdf, + 0xe7, 0x31, 0x1, 0x4a, 0xff, 0x90, 0x0, 0x0, + 0x3, 0xff, 0x80, 0x0, 0x0, 0x0, 0x2, 0xcf, + 0xb0, 0x0, 0x1, 0xef, 0x50, 0x0, 0x37, 0x86, + 0x20, 0x0, 0xaf, 0x90, 0x0, 0x9f, 0x60, 0x1, + 0xcf, 0xff, 0xff, 0x80, 0x0, 0xdf, 0x30, 0x2f, + 0xc0, 0x0, 0xdf, 0x92, 0x3, 0xcf, 0x70, 0x2, + 0xfc, 0x7, 0xf4, 0x0, 0x7f, 0xa0, 0x0, 0x0, + 0xdd, 0x0, 0xa, 0xf1, 0xcf, 0x0, 0xd, 0xf2, + 0x0, 0x0, 0x1, 0x0, 0x0, 0x5f, 0x6e, 0xc0, + 0x0, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xf8, 0xfb, 0x0, 0x1f, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0x9e, 0xc0, 0x0, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xf8, 0xde, 0x0, + 0xd, 0xf1, 0x0, 0x0, 0x5, 0x71, 0x0, 0x4f, + 0x79, 0xf3, 0x0, 0x7f, 0x80, 0x0, 0x1, 0xef, + 0x0, 0x9, 0xf3, 0x4f, 0xa0, 0x0, 0xef, 0x71, + 0x4, 0xdf, 0x80, 0x1, 0xed, 0x0, 0xcf, 0x30, + 0x2, 0xdf, 0xff, 0xff, 0x80, 0x0, 0x9f, 0x60, + 0x3, 0xfe, 0x20, 0x0, 0x58, 0x97, 0x20, 0x0, + 0x6f, 0xc0, 0x0, 0x5, 0xfe, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xe1, 0x0, 0x0, 0x6, 0xff, + 0xa3, 0x0, 0x0, 0x5, 0xdf, 0xd1, 0x0, 0x0, + 0x0, 0x3, 0xcf, 0xfe, 0xcc, 0xdf, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x49, 0xde, 0xfe, + 0xc7, 0x20, 0x0, 0x0, 0x0, + + /* U+00AA "ª" */ + 0x0, 0x6d, 0xfe, 0x81, 0xff, 0x0, 0x8f, 0xe9, + 0xaf, 0xdf, 0xa0, 0x2f, 0xf3, 0x0, 0x6f, 0xf6, + 0x6, 0xfb, 0x0, 0x0, 0xff, 0x30, 0x8f, 0x90, + 0x0, 0xd, 0xf0, 0x8, 0xf9, 0x0, 0x0, 0xdf, + 0x0, 0x6f, 0xb0, 0x0, 0xf, 0xf3, 0x1, 0xff, + 0x20, 0x8, 0xff, 0x60, 0x8, 0xfe, 0x9b, 0xfd, + 0xfa, 0x0, 0x7, 0xdf, 0xe8, 0x1f, 0xf0, + + /* U+00AB "«" */ + 0x0, 0x0, 0x8, 0x91, 0x0, 0x69, 0x40, 0x0, + 0x8, 0xfa, 0x0, 0x3f, 0xe1, 0x0, 0x3, 0xff, + 0x10, 0xd, 0xf6, 0x0, 0x0, 0xdf, 0x80, 0x9, + 0xfd, 0x0, 0x0, 0x9f, 0xe0, 0x4, 0xff, 0x40, + 0x0, 0x4f, 0xf6, 0x0, 0xef, 0xb0, 0x0, 0xe, + 0xfd, 0x0, 0x8f, 0xf2, 0x0, 0x0, 0x8f, 0xf2, + 0x3, 0xff, 0x70, 0x0, 0x0, 0xdf, 0xb0, 0x8, + 0xff, 0x10, 0x0, 0x3, 0xff, 0x40, 0xd, 0xf9, + 0x0, 0x0, 0x7, 0xfd, 0x0, 0x3f, 0xf2, 0x0, + 0x0, 0xc, 0xf6, 0x0, 0x7f, 0xb0, 0x0, 0x0, + 0x2f, 0xe0, 0x0, 0xcf, 0x50, + + /* U+00AC "¬" */ + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x7f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x25, 0x55, + 0x55, 0x55, 0x55, 0x5a, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x54, + + /* U+00AD "­" */ + 0x8, 0x88, 0x88, 0x88, 0x31, 0xff, 0xff, 0xff, + 0xf7, 0x1f, 0xff, 0xff, 0xff, 0x70, + + /* U+00AE "®" */ + 0x0, 0x0, 0x0, 0x4, 0x8a, 0xb9, 0x73, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7e, 0xff, 0xff, + 0xff, 0xfd, 0x40, 0x0, 0x0, 0x0, 0x2, 0xdf, + 0xe7, 0x31, 0x1, 0x4a, 0xff, 0x90, 0x0, 0x0, + 0x3, 0xff, 0x80, 0x0, 0x0, 0x0, 0x2, 0xcf, + 0xb0, 0x0, 0x1, 0xef, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0x90, 0x0, 0x9f, 0x60, 0x3f, + 0xff, 0xff, 0xea, 0x10, 0x0, 0xdf, 0x30, 0x2f, + 0xc0, 0x3, 0xfc, 0x88, 0x9d, 0xfd, 0x0, 0x2, + 0xfc, 0x7, 0xf4, 0x0, 0x3f, 0x90, 0x0, 0xc, + 0xf4, 0x0, 0xa, 0xf1, 0xcf, 0x0, 0x3, 0xf9, + 0x0, 0x0, 0x9f, 0x40, 0x0, 0x5f, 0x6e, 0xc0, + 0x0, 0x3f, 0x90, 0x1, 0x5f, 0xe0, 0x0, 0x2, + 0xf8, 0xfb, 0x0, 0x3, 0xff, 0xff, 0xff, 0xe3, + 0x0, 0x0, 0x1f, 0x9e, 0xc0, 0x0, 0x3f, 0xd8, + 0xbf, 0xb0, 0x0, 0x0, 0x2, 0xf8, 0xde, 0x0, + 0x3, 0xf9, 0x0, 0x5f, 0x90, 0x0, 0x0, 0x4f, + 0x79, 0xf3, 0x0, 0x3f, 0x90, 0x0, 0xaf, 0x50, + 0x0, 0x9, 0xf3, 0x4f, 0xa0, 0x3, 0xf9, 0x0, + 0x1, 0xfe, 0x10, 0x1, 0xed, 0x0, 0xcf, 0x30, + 0x3f, 0x90, 0x0, 0x8, 0xf9, 0x0, 0x9f, 0x60, + 0x3, 0xfe, 0x21, 0x53, 0x0, 0x0, 0x5, 0x50, + 0x6f, 0xc0, 0x0, 0x5, 0xfe, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xe1, 0x0, 0x0, 0x6, 0xff, + 0xa3, 0x0, 0x0, 0x5, 0xdf, 0xd1, 0x0, 0x0, + 0x0, 0x3, 0xcf, 0xfe, 0xcc, 0xdf, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x49, 0xde, 0xfe, + 0xc7, 0x20, 0x0, 0x0, 0x0, + + /* U+00B0 "°" */ + 0x0, 0x0, 0x10, 0x0, 0x0, 0x6, 0xef, 0xf9, + 0x0, 0x6, 0xfb, 0x69, 0xf9, 0x0, 0xeb, 0x0, + 0x8, 0xf2, 0x2f, 0x50, 0x0, 0x2f, 0x52, 0xf6, + 0x0, 0x3, 0xf5, 0xe, 0xc0, 0x0, 0xaf, 0x10, + 0x5f, 0xd8, 0xcf, 0x80, 0x0, 0x4c, 0xfd, 0x60, + 0x0, + + /* U+00B1 "±" */ + 0x0, 0x0, 0x0, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0x50, 0x0, 0x0, 0x25, 0x55, 0x55, 0xff, 0x85, + 0x55, 0x53, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x66, 0x20, + 0x0, 0x0, 0x25, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x54, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + + /* U+00B2 "²" */ + 0x0, 0x8d, 0xff, 0xc6, 0x0, 0xbf, 0xea, 0xbf, + 0xf6, 0x3f, 0xe1, 0x0, 0x8f, 0xb0, 0x1, 0x0, + 0x7, 0xfa, 0x0, 0x0, 0x4, 0xff, 0x30, 0x0, + 0x8, 0xff, 0x40, 0x0, 0x1c, 0xfc, 0x20, 0x0, + 0x2e, 0xf9, 0x0, 0x0, 0x1e, 0xfe, 0xaa, 0xaa, + 0x88, 0xff, 0xff, 0xff, 0xfd, + + /* U+00B3 "³" */ + 0x0, 0x9e, 0xfe, 0xb4, 0x0, 0xcf, 0xc8, 0xbf, + 0xf1, 0x19, 0xa0, 0x0, 0xdf, 0x40, 0x0, 0x2, + 0x6f, 0xe1, 0x0, 0x0, 0xff, 0xe3, 0x0, 0x0, + 0x5, 0x7e, 0xf4, 0x0, 0x0, 0x0, 0x5f, 0xc5, + 0xeb, 0x0, 0x9, 0xfb, 0xd, 0xfd, 0xac, 0xff, + 0x40, 0x19, 0xdf, 0xeb, 0x30, + + /* U+00B5 "µ" */ + 0x1f, 0xf5, 0x0, 0x0, 0x0, 0xcf, 0xa1, 0xff, + 0x50, 0x0, 0x0, 0xc, 0xfa, 0x1f, 0xf5, 0x0, + 0x0, 0x0, 0xcf, 0xa1, 0xff, 0x50, 0x0, 0x0, + 0xc, 0xfa, 0x1f, 0xf5, 0x0, 0x0, 0x0, 0xcf, + 0xa1, 0xff, 0x50, 0x0, 0x0, 0xc, 0xfa, 0x1f, + 0xf5, 0x0, 0x0, 0x0, 0xcf, 0xa1, 0xff, 0x50, + 0x0, 0x0, 0xc, 0xfa, 0x1f, 0xf6, 0x0, 0x0, + 0x0, 0xdf, 0xa1, 0xff, 0x70, 0x0, 0x0, 0xe, + 0xfa, 0x1f, 0xfb, 0x0, 0x0, 0x2, 0xff, 0xa1, + 0xff, 0xf4, 0x0, 0x0, 0xbf, 0xfa, 0x1f, 0xff, + 0xf8, 0x46, 0xcf, 0xff, 0xa1, 0xff, 0xbf, 0xff, + 0xff, 0xea, 0xfa, 0x1f, 0xf5, 0x5c, 0xfe, 0xa1, + 0x9f, 0xa1, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+00B6 "¶" */ + 0x0, 0x1, 0x8c, 0xef, 0xff, 0xff, 0xff, 0xff, + 0x10, 0x4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf1, 0x2, 0xff, 0xff, 0xff, 0xd6, 0x68, 0xff, + 0x76, 0x0, 0xaf, 0xff, 0xff, 0xfb, 0x0, 0x3f, + 0xf1, 0x0, 0xe, 0xff, 0xff, 0xff, 0xb0, 0x3, + 0xff, 0x10, 0x0, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0x3f, 0xf1, 0x0, 0xf, 0xff, 0xff, 0xff, 0xb0, + 0x3, 0xff, 0x10, 0x0, 0xdf, 0xff, 0xff, 0xfb, + 0x0, 0x3f, 0xf1, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xb0, 0x3, 0xff, 0x10, 0x0, 0xc, 0xff, 0xff, + 0xfb, 0x0, 0x3f, 0xf1, 0x0, 0x0, 0x1a, 0xff, + 0xff, 0xb0, 0x3, 0xff, 0x10, 0x0, 0x0, 0x1, + 0x5b, 0xfb, 0x0, 0x3f, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xb0, 0x3, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x8, 0xfb, 0x0, 0x3f, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xb0, 0x3, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x8, 0xfb, 0x0, 0x3f, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xb0, 0x3, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x8, 0xfb, 0x0, 0x3f, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xb0, 0x3, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x8, 0xfb, 0x0, 0x3f, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xb0, 0x3, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x8, 0xfb, 0x0, + 0x3f, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xb0, + 0x3, 0xff, 0x10, 0x0, 0x0, 0x0, 0x8, 0xfb, + 0x0, 0x3f, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xb0, 0x3, 0xff, 0x10, 0x0, 0x0, 0x0, 0x8, + 0xfb, 0x0, 0x3f, 0xf1, 0x0, + + /* U+00B7 "·" */ + 0x6d, 0xd4, 0x7f, 0xf5, 0x7f, 0xf5, + + /* U+00BB "»" */ + 0x8, 0x92, 0x0, 0x59, 0x50, 0x0, 0x0, 0x6f, + 0xc0, 0x1, 0xff, 0x20, 0x0, 0x0, 0xdf, 0x70, + 0x8, 0xfc, 0x0, 0x0, 0x4, 0xff, 0x20, 0xe, + 0xf7, 0x0, 0x0, 0xa, 0xfc, 0x0, 0x6f, 0xf2, + 0x0, 0x0, 0x2f, 0xf8, 0x0, 0xcf, 0xd0, 0x0, + 0x0, 0x9f, 0xf2, 0x4, 0xff, 0x70, 0x0, 0xd, + 0xfc, 0x0, 0x9f, 0xf2, 0x0, 0x7, 0xff, 0x20, + 0x2f, 0xf7, 0x0, 0x1, 0xff, 0x60, 0xb, 0xfb, + 0x0, 0x0, 0x9f, 0xb0, 0x4, 0xff, 0x10, 0x0, + 0x2f, 0xf1, 0x0, 0xdf, 0x50, 0x0, 0xb, 0xf5, + 0x0, 0x6f, 0xa0, 0x0, 0x0, + + /* U+00BD "½" */ + 0x0, 0x6, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xe1, 0x0, 0x0, 0x8f, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0x40, 0x0, 0x4d, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x9, 0xf8, 0x0, + 0x0, 0x8e, 0x77, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xd0, 0x0, 0x0, 0x10, 0x7, 0xf8, 0x0, + 0x0, 0x0, 0x1, 0xef, 0x30, 0x0, 0x0, 0x0, + 0x7, 0xf8, 0x0, 0x0, 0x0, 0xa, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xf8, 0x0, 0x0, 0x0, + 0x6f, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xf8, + 0x0, 0x0, 0x2, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xf8, 0x0, 0x0, 0xc, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xf8, 0x0, 0x0, + 0x7f, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x52, 0x0, 0x3, 0xfe, 0x10, 0x2, 0x79, 0x97, + 0x10, 0x0, 0x0, 0x0, 0x0, 0xd, 0xf4, 0x0, + 0x5f, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0x90, 0x1, 0xff, 0x50, 0x1b, 0xfa, 0x0, + 0x0, 0x0, 0x4, 0xfd, 0x0, 0x2, 0x87, 0x0, + 0x6, 0xfc, 0x0, 0x0, 0x0, 0x1e, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xf8, 0x0, 0x0, 0x0, + 0xaf, 0x70, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xe1, + 0x0, 0x0, 0x6, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x2d, 0xfd, 0x20, 0x0, 0x0, 0x2f, 0xf1, 0x0, + 0x0, 0x0, 0x4, 0xef, 0xb1, 0x0, 0x0, 0x0, + 0xcf, 0x50, 0x0, 0x0, 0x0, 0x4f, 0xf8, 0x0, + 0x0, 0x0, 0x7, 0xfa, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xea, 0xaa, 0xa9, 0x0, 0x3f, 0xe1, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xfd, 0x0, + 0x58, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0384 "΄" */ + 0x4, 0xee, 0xa0, 0xc, 0xfe, 0x10, 0x4f, 0xf4, + 0x0, 0xbf, 0x70, 0x0, + + /* U+0386 "Ά" */ + 0x0, 0xa, 0xff, 0x60, 0x8f, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xf9, 0x0, 0xef, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xc0, 0x4, + 0xff, 0xdf, 0x90, 0x0, 0x0, 0x0, 0x1, 0xdd, + 0x20, 0xa, 0xfb, 0x8f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xf7, 0x2f, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf1, 0xd, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xc0, 0x7, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0x60, 0x1, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0x0, 0x0, 0xbf, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xfa, 0x0, 0x0, + 0x5f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf4, + 0x0, 0x0, 0xe, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xe2, 0x22, 0x22, 0x2a, 0xff, 0x40, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0xe, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xf7, 0x0, 0x0, 0x4f, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xfe, 0x0, + 0x0, 0xaf, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0x40, 0x1, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xb0, 0x7, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf2, 0xd, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf8, + + /* U+0388 "Έ" */ + 0x0, 0xaf, 0xf7, 0x8, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x0, 0x1f, 0xfa, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x9, + 0xfd, 0x0, 0x8, 0xff, 0x76, 0x66, 0x66, 0x66, + 0x66, 0x66, 0x0, 0xdd, 0x20, 0x0, 0x8f, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0x76, 0x66, 0x66, 0x66, 0x66, 0x61, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xf7, 0x66, 0x66, 0x66, 0x66, 0x66, 0x62, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, + + /* U+0389 "Ή" */ + 0x0, 0xaf, 0xf7, 0x1f, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xa0, 0x1f, 0xfa, 0x1, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0xf, 0xfa, 0x9, + 0xfd, 0x0, 0x1f, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xa0, 0xdd, 0x20, 0x1, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, + 0x0, 0x1f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xa0, 0x0, 0x0, 0x1, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, + 0x1f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xa0, 0x0, 0x0, 0x1, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x1f, 0xfb, + 0x66, 0x66, 0x66, 0x66, 0x66, 0xff, 0xa0, 0x0, + 0x0, 0x1, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xfa, 0x0, 0x0, 0x0, 0x1f, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xa0, 0x0, 0x0, + 0x1, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xfa, 0x0, 0x0, 0x0, 0x1f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xa0, 0x0, 0x0, 0x1, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0xf, 0xfa, + 0x0, 0x0, 0x0, 0x1f, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xa0, 0x0, 0x0, 0x1, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, + 0x0, 0x0, 0x1f, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xa0, 0x0, 0x0, 0x1, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xfa, + + /* U+038A "Ί" */ + 0x0, 0xaf, 0xf7, 0x1f, 0xf9, 0x1, 0xff, 0xa0, + 0x1f, 0xf9, 0x9, 0xfd, 0x0, 0x1f, 0xf9, 0xd, + 0xd2, 0x0, 0x1f, 0xf9, 0x0, 0x0, 0x0, 0x1f, + 0xf9, 0x0, 0x0, 0x0, 0x1f, 0xf9, 0x0, 0x0, + 0x0, 0x1f, 0xf9, 0x0, 0x0, 0x0, 0x1f, 0xf9, + 0x0, 0x0, 0x0, 0x1f, 0xf9, 0x0, 0x0, 0x0, + 0x1f, 0xf9, 0x0, 0x0, 0x0, 0x1f, 0xf9, 0x0, + 0x0, 0x0, 0x1f, 0xf9, 0x0, 0x0, 0x0, 0x1f, + 0xf9, 0x0, 0x0, 0x0, 0x1f, 0xf9, 0x0, 0x0, + 0x0, 0x1f, 0xf9, 0x0, 0x0, 0x0, 0x1f, 0xf9, + 0x0, 0x0, 0x0, 0x1f, 0xf9, 0x0, 0x0, 0x0, + 0x1f, 0xf9, 0x0, 0x0, 0x0, 0x1f, 0xf9, 0x0, + 0x0, 0x0, 0x1f, 0xf9, + + /* U+038C "Ό" */ + 0x0, 0xaf, 0xf7, 0x0, 0x17, 0xbe, 0xff, 0xda, + 0x50, 0x0, 0x0, 0x0, 0x1f, 0xfa, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0xd4, 0x0, 0x0, 0x9, + 0xfd, 0x1, 0xcf, 0xff, 0xa6, 0x55, 0x8d, 0xff, + 0xf6, 0x0, 0x0, 0xdd, 0x20, 0xbf, 0xfb, 0x10, + 0x0, 0x0, 0x5, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x6f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xe0, 0x0, 0x0, 0xe, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0x70, 0x0, 0x4, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xfd, + 0x0, 0x0, 0x8f, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xf1, 0x0, 0xa, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x40, + 0x0, 0xbf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xf5, 0x0, 0xc, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0x50, 0x0, + 0xaf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xf4, 0x0, 0x8, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0x10, 0x0, 0x3f, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xd0, 0x0, 0x0, 0xef, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf7, 0x0, 0x0, 0x6, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfe, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xb1, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x40, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xfa, 0x65, 0x58, 0xdf, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x7b, + 0xef, 0xfd, 0xa5, 0x0, 0x0, 0x0, + + /* U+038E "Ύ" */ + 0x0, 0xaf, 0xf7, 0x7, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf3, 0x1, 0xff, 0xa0, + 0x0, 0xcf, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0x80, 0x9, 0xfd, 0x0, 0x0, 0x2f, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x3f, 0xfd, 0x0, 0xd, + 0xd2, 0x0, 0x0, 0x7, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0xcf, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xf5, 0x0, 0x0, 0x7, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xfe, + 0x10, 0x0, 0x2f, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xa0, 0x0, 0xcf, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xf4, 0x6, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xfd, + 0x1f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xef, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf9, + 0x0, 0x0, 0x0, 0x0, + + /* U+038F "Ώ" */ + 0x0, 0xaf, 0xf7, 0x0, 0x28, 0xce, 0xff, 0xd9, + 0x40, 0x0, 0x0, 0x1, 0xff, 0xa0, 0x7, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x9, 0xfd, + 0x0, 0xaf, 0xff, 0xa6, 0x45, 0x9f, 0xff, 0xd1, + 0x0, 0xd, 0xd2, 0x7, 0xff, 0xe3, 0x0, 0x0, + 0x1, 0xcf, 0xfb, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x20, 0x0, 0x0, 0x0, 0xd, 0xff, 0x60, 0x0, + 0x0, 0x9f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xd0, 0x0, 0x0, 0xef, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xf2, 0x0, 0x2, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf6, + 0x0, 0x4, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xf7, 0x0, 0x4, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf8, 0x0, 0x3, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xf7, 0x0, 0x1, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xf4, 0x0, 0x0, 0xcf, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf0, 0x0, + 0x0, 0x6f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xa0, 0x0, 0x0, 0xd, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0x20, 0x0, 0x0, 0x3, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x1e, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf5, 0x0, 0x0, 0x2, + 0xdf, 0x80, 0x0, 0x0, 0x3, 0x66, 0x6b, 0xff, + 0xa1, 0x0, 0x8f, 0xfd, 0x66, 0x64, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0xff, 0xff, 0xff, + 0xfc, 0x0, 0x8, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0xff, 0xff, 0xff, 0xfc, + + /* U+0390 "ΐ" */ + 0x0, 0x0, 0x1f, 0xf6, 0x0, 0x8, 0xa5, 0x7, + 0xfb, 0x2a, 0xa0, 0xdf, 0x80, 0xee, 0x14, 0xff, + 0x1d, 0xf8, 0x6f, 0x50, 0x4f, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x2f, 0xf5, 0x0, 0x0, 0x0, 0x2, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x2f, 0xf5, 0x0, 0x0, 0x0, + 0x2, 0xff, 0x50, 0x0, 0x0, 0x0, 0x2f, 0xf5, + 0x0, 0x0, 0x0, 0x2, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x2f, 0xf5, 0x0, 0x0, 0x0, 0x2, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x2f, 0xf5, 0x0, 0x0, + 0x0, 0x2, 0xff, 0x50, 0x0, 0x0, 0x0, 0x2f, + 0xf5, 0x0, 0x0, 0x0, 0x2, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x2f, 0xf5, 0x0, 0x0, 0x0, 0x2, + 0xff, 0x50, 0x0, 0x0, + + /* U+0391 "Α" */ + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xdf, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xfb, 0x8f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xf6, 0x2f, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf1, 0xd, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xc0, 0x7, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0x60, 0x1, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0x0, 0x0, 0xbf, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xfa, 0x0, 0x0, + 0x5f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf4, + 0x0, 0x0, 0xe, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xe2, 0x22, 0x22, 0x2a, 0xff, 0x40, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0xe, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xf7, 0x0, 0x0, 0x4f, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xfe, 0x0, + 0x0, 0xaf, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0x40, 0x1, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xb0, 0x7, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf2, 0xd, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf8, + + /* U+0392 "Β" */ + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x93, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0xff, 0xd6, 0x66, 0x66, 0x7a, 0xff, 0xf8, 0x0, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0x0, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x30, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x6, 0xff, 0x20, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0xa, 0xfe, 0x0, + 0xff, 0xb0, 0x0, 0x0, 0x13, 0x9f, 0xf5, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x40, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, + 0xff, 0xd6, 0x66, 0x66, 0x79, 0xef, 0xfc, 0x0, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x90, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf0, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf2, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf2, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf0, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xb0, + 0xff, 0xd6, 0x66, 0x66, 0x68, 0xdf, 0xff, 0x20, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe4, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0xb7, 0x10, 0x0, + + /* U+0393 "Γ" */ + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcc, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0xcf, 0xe6, 0x66, + 0x66, 0x66, 0x66, 0x4c, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0394 "Δ" */ + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xfe, 0xdf, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xfb, 0x8f, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xf6, 0x2f, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf1, 0xd, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xb0, 0x7, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0x50, 0x1, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0x0, 0x0, 0xaf, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, + 0x4f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf4, + 0x0, 0x0, 0xe, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xe0, 0x0, 0x0, 0x8, 0xff, 0x30, 0x0, + 0x0, 0x2, 0xff, 0x80, 0x0, 0x0, 0x2, 0xff, + 0xa0, 0x0, 0x0, 0x8, 0xff, 0x20, 0x0, 0x0, + 0x0, 0xcf, 0xf1, 0x0, 0x0, 0xe, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xf7, 0x0, 0x0, 0x4f, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0xf, 0xfe, 0x0, + 0x0, 0xaf, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0x40, 0x1, 0xff, 0xd6, 0x66, 0x66, 0x66, + 0x66, 0x69, 0xff, 0xb0, 0x7, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0xd, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + + /* U+0395 "Ε" */ + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, + 0xcf, 0xe6, 0x66, 0x66, 0x66, 0x66, 0x66, 0x40, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xe6, 0x66, 0x66, 0x66, 0x66, 0x65, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xe6, 0x66, 0x66, 0x66, 0x66, 0x66, 0x61, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + + /* U+0396 "Ζ" */ + 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf0, 0x2, 0x66, 0x66, 0x66, 0x66, 0x66, 0xaf, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2e, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xe6, 0x66, 0x66, 0x66, 0x66, 0x66, + 0x62, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x58, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf5, + + /* U+0397 "Η" */ + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xcf, 0xe6, 0x66, 0x66, 0x66, 0x66, 0x6c, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + + /* U+0398 "Θ" */ + 0x0, 0x0, 0x1, 0x6b, 0xef, 0xfd, 0xa5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0xe5, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, + 0x75, 0x57, 0xcf, 0xff, 0x70, 0x0, 0x0, 0x9f, + 0xfc, 0x20, 0x0, 0x0, 0x4, 0xef, 0xf6, 0x0, + 0x4, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x2e, + 0xff, 0x10, 0xc, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0x90, 0x2f, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf0, 0x6f, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf3, + 0x8f, 0xf2, 0x0, 0x66, 0x66, 0x66, 0x65, 0x0, + 0x5f, 0xf5, 0xaf, 0xf1, 0x1, 0xff, 0xff, 0xff, + 0xfd, 0x0, 0x4f, 0xf7, 0xaf, 0xf1, 0x1, 0xff, + 0xff, 0xff, 0xfd, 0x0, 0x4f, 0xf7, 0x8f, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf5, + 0x6f, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf3, 0x1f, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf0, 0xc, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0x90, 0x5, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, 0x10, + 0x0, 0xaf, 0xfc, 0x20, 0x0, 0x0, 0x4, 0xef, + 0xf6, 0x0, 0x0, 0xb, 0xff, 0xfb, 0x65, 0x57, + 0xcf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xe5, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x7b, 0xef, 0xfd, 0xa5, 0x0, 0x0, 0x0, + + /* U+0399 "Ι" */ + 0x6f, 0xf3, 0x6f, 0xf3, 0x6f, 0xf3, 0x6f, 0xf3, + 0x6f, 0xf3, 0x6f, 0xf3, 0x6f, 0xf3, 0x6f, 0xf3, + 0x6f, 0xf3, 0x6f, 0xf3, 0x6f, 0xf3, 0x6f, 0xf3, + 0x6f, 0xf3, 0x6f, 0xf3, 0x6f, 0xf3, 0x6f, 0xf3, + 0x6f, 0xf3, 0x6f, 0xf3, 0x6f, 0xf3, 0x6f, 0xf3, + + /* U+039A "Κ" */ + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfb, + 0xf, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfa, + 0x0, 0xff, 0xb0, 0x0, 0x0, 0x0, 0xcf, 0xfa, + 0x0, 0xf, 0xfb, 0x0, 0x0, 0x0, 0xcf, 0xfa, + 0x0, 0x0, 0xff, 0xb0, 0x0, 0x0, 0xcf, 0xf9, + 0x0, 0x0, 0xf, 0xfb, 0x0, 0x0, 0xcf, 0xf8, + 0x0, 0x0, 0x0, 0xff, 0xb0, 0x0, 0xcf, 0xf8, + 0x0, 0x0, 0x0, 0xf, 0xfb, 0x0, 0xcf, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xb1, 0xcf, 0xff, + 0x20, 0x0, 0x0, 0x0, 0xf, 0xfc, 0xcf, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf5, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf5, + 0x0, 0xdf, 0xf5, 0x0, 0x0, 0x0, 0xff, 0xf5, + 0x0, 0x2, 0xff, 0xf2, 0x0, 0x0, 0xf, 0xfb, + 0x0, 0x0, 0x7, 0xff, 0xc0, 0x0, 0x0, 0xff, + 0xb0, 0x0, 0x0, 0xb, 0xff, 0x90, 0x0, 0xf, + 0xfb, 0x0, 0x0, 0x0, 0x1e, 0xff, 0x50, 0x0, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x5f, 0xfe, 0x10, + 0xf, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfc, + 0x0, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xf8, 0xf, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf4, + + /* U+039B "Λ" */ + 0x0, 0x0, 0x0, 0x3, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xfc, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xfe, 0x4f, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0x90, 0xef, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xf4, 0x9, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xfe, 0x0, 0x3f, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0x80, 0x0, + 0xef, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf2, + 0x0, 0x8, 0xff, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xfc, 0x0, 0x0, 0x2f, 0xf6, 0x0, 0x0, 0x0, + 0x2, 0xff, 0x60, 0x0, 0x0, 0xdf, 0xc0, 0x0, + 0x0, 0x0, 0x8f, 0xf0, 0x0, 0x0, 0x7, 0xff, + 0x20, 0x0, 0x0, 0xe, 0xfa, 0x0, 0x0, 0x0, + 0x1f, 0xf9, 0x0, 0x0, 0x4, 0xff, 0x40, 0x0, + 0x0, 0x0, 0xbf, 0xe0, 0x0, 0x0, 0xbf, 0xe0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0x50, 0x0, 0x1f, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0xf, 0xfb, 0x0, + 0x7, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xf2, 0x0, 0xdf, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0x80, 0x4f, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xfe, 0xa, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, + + /* U+039C "Μ" */ + 0xef, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xf3, 0xef, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf3, 0xef, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf3, 0xef, 0xdf, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xef, 0xf3, + 0xef, 0xad, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xef, + 0x9f, 0xf3, 0xef, 0xa7, 0xfe, 0x0, 0x0, 0x0, + 0x3, 0xfe, 0x5f, 0xf3, 0xef, 0xa2, 0xff, 0x40, + 0x0, 0x0, 0x9, 0xf8, 0x5f, 0xf3, 0xef, 0xa0, + 0xcf, 0x90, 0x0, 0x0, 0xe, 0xf3, 0x5f, 0xf3, + 0xef, 0xa0, 0x7f, 0xe0, 0x0, 0x0, 0x4f, 0xd0, + 0x5f, 0xf3, 0xef, 0xa0, 0x2f, 0xf4, 0x0, 0x0, + 0x9f, 0x80, 0x5f, 0xf3, 0xef, 0xa0, 0xc, 0xf9, + 0x0, 0x0, 0xef, 0x20, 0x5f, 0xf3, 0xef, 0xa0, + 0x7, 0xfe, 0x0, 0x4, 0xfc, 0x0, 0x5f, 0xf3, + 0xef, 0xa0, 0x1, 0xff, 0x40, 0xa, 0xf7, 0x0, + 0x5f, 0xf3, 0xef, 0xa0, 0x0, 0xcf, 0x90, 0xf, + 0xf1, 0x0, 0x5f, 0xf3, 0xef, 0xa0, 0x0, 0x6f, + 0xe0, 0x5f, 0xc0, 0x0, 0x5f, 0xf3, 0xef, 0xa0, + 0x0, 0x1f, 0xf4, 0xaf, 0x60, 0x0, 0x5f, 0xf3, + 0xef, 0xa0, 0x0, 0xb, 0xfa, 0xff, 0x10, 0x0, + 0x5f, 0xf3, 0xef, 0xa0, 0x0, 0x6, 0xff, 0xfb, + 0x0, 0x0, 0x5f, 0xf3, 0xef, 0xa0, 0x0, 0x1, + 0xff, 0xf6, 0x0, 0x0, 0x5f, 0xf3, 0xef, 0xa0, + 0x0, 0x0, 0xbf, 0xf0, 0x0, 0x0, 0x5f, 0xf3, + + /* U+039D "Ν" */ + 0xcf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xcf, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xcf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xcf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xcf, 0xdf, 0xfe, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xcf, 0xc6, 0xff, 0xa0, 0x0, 0x0, 0x8, 0xff, + 0xcf, 0xc0, 0xbf, 0xf4, 0x0, 0x0, 0x8, 0xff, + 0xcf, 0xc0, 0x2f, 0xfe, 0x10, 0x0, 0x8, 0xff, + 0xcf, 0xc0, 0x6, 0xff, 0xa0, 0x0, 0x8, 0xff, + 0xcf, 0xc0, 0x0, 0xbf, 0xf4, 0x0, 0x8, 0xff, + 0xcf, 0xc0, 0x0, 0x2f, 0xfe, 0x10, 0x8, 0xff, + 0xcf, 0xc0, 0x0, 0x6, 0xff, 0xa0, 0x8, 0xff, + 0xcf, 0xc0, 0x0, 0x0, 0xbf, 0xf5, 0x8, 0xff, + 0xcf, 0xc0, 0x0, 0x0, 0x1f, 0xfe, 0x18, 0xff, + 0xcf, 0xc0, 0x0, 0x0, 0x6, 0xff, 0xa8, 0xff, + 0xcf, 0xc0, 0x0, 0x0, 0x0, 0xbf, 0xfd, 0xff, + 0xcf, 0xc0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xcf, 0xc0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xcf, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xcf, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + + /* U+039E "Ξ" */ + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x6, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x62, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x56, 0x66, 0x66, 0x66, 0x66, 0x66, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x36, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x64, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, + + /* U+039F "Ο" */ + 0x0, 0x0, 0x1, 0x6b, 0xef, 0xfd, 0xa5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0xe5, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, + 0x75, 0x57, 0xcf, 0xff, 0x70, 0x0, 0x0, 0x9f, + 0xfc, 0x20, 0x0, 0x0, 0x4, 0xef, 0xf6, 0x0, + 0x4, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x2e, + 0xff, 0x10, 0xc, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0x90, 0x2f, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf0, 0x6f, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf3, + 0x8f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xf5, 0xaf, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xf7, 0xaf, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf7, 0x8f, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf5, + 0x6f, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf3, 0x1f, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf0, 0xc, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0x90, 0x5, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, 0x10, + 0x0, 0xaf, 0xfc, 0x20, 0x0, 0x0, 0x4, 0xef, + 0xf6, 0x0, 0x0, 0xb, 0xff, 0xfb, 0x65, 0x57, + 0xcf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xe5, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x7b, 0xef, 0xfd, 0xa5, 0x0, 0x0, 0x0, + + /* U+03A0 "Π" */ + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xcf, 0xe6, 0x66, 0x66, 0x66, 0x66, 0x6c, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + + /* U+03A1 "Ρ" */ + 0xdf, 0xff, 0xff, 0xff, 0xfe, 0xda, 0x30, 0x0, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, + 0xdf, 0xe6, 0x66, 0x66, 0x67, 0xaf, 0xff, 0x70, + 0xdf, 0xd0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf0, + 0xdf, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, + 0xdf, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf6, + 0xdf, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf6, + 0xdf, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf3, + 0xdf, 0xd0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xe0, + 0xdf, 0xe6, 0x66, 0x66, 0x68, 0xcf, 0xff, 0x50, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0xdf, 0xff, 0xff, 0xff, 0xfe, 0xc8, 0x20, 0x0, + 0xdf, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A3 "Σ" */ + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0xf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0xef, + 0xf8, 0x66, 0x66, 0x66, 0x66, 0x64, 0x3, 0xff, + 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xdf, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x76, 0x66, 0x66, 0x66, 0x66, 0x61, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, + + /* U+03A4 "Τ" */ + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x76, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf7, 0x26, 0x66, 0x66, 0x6e, 0xfe, 0x66, 0x66, + 0x66, 0x30, 0x0, 0x0, 0x0, 0xcf, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xd0, 0x0, + 0x0, 0x0, + + /* U+03A5 "Υ" */ + 0x9f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0x20, 0xdf, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0x60, 0x4, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xb0, 0x0, 0x9, 0xff, 0x90, + 0x0, 0x0, 0x0, 0xef, 0xe1, 0x0, 0x0, 0xd, + 0xff, 0x40, 0x0, 0x0, 0x9f, 0xf5, 0x0, 0x0, + 0x0, 0x3f, 0xfd, 0x0, 0x0, 0x4f, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf8, 0x0, 0xd, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf3, 0x8, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xc2, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xef, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xf7, 0x0, 0x0, 0x0, 0x0, + + /* U+03A6 "Φ" */ + 0x0, 0x0, 0x0, 0x0, 0x19, 0x94, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0x8c, 0xef, 0xff, 0xfe, 0xd9, 0x40, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xc2, 0x0, 0x0, 0xa, 0xff, 0xe9, + 0x55, 0xff, 0x94, 0x7d, 0xff, 0xe2, 0x0, 0x7, + 0xff, 0xb1, 0x0, 0x2f, 0xf8, 0x0, 0x7, 0xff, + 0xd0, 0x1, 0xff, 0xd0, 0x0, 0x2, 0xff, 0x80, + 0x0, 0x9, 0xff, 0x70, 0x7f, 0xf5, 0x0, 0x0, + 0x2f, 0xf8, 0x0, 0x0, 0x1f, 0xfd, 0xb, 0xff, + 0x10, 0x0, 0x2, 0xff, 0x80, 0x0, 0x0, 0xbf, + 0xf0, 0xdf, 0xf0, 0x0, 0x0, 0x2f, 0xf8, 0x0, + 0x0, 0x9, 0xff, 0x2c, 0xff, 0x0, 0x0, 0x2, + 0xff, 0x80, 0x0, 0x0, 0x9f, 0xf1, 0xbf, 0xf1, + 0x0, 0x0, 0x2f, 0xf8, 0x0, 0x0, 0xb, 0xff, + 0x7, 0xff, 0x60, 0x0, 0x2, 0xff, 0x80, 0x0, + 0x0, 0xef, 0xc0, 0x2f, 0xfd, 0x0, 0x0, 0x2f, + 0xf8, 0x0, 0x0, 0x8f, 0xf6, 0x0, 0x8f, 0xfc, + 0x10, 0x2, 0xff, 0x80, 0x0, 0x7f, 0xfd, 0x0, + 0x0, 0xbf, 0xff, 0x95, 0x5f, 0xf9, 0x47, 0xdf, + 0xfe, 0x20, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x10, 0x0, 0x0, 0x0, 0x17, + 0xbe, 0xff, 0xff, 0xed, 0x93, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + + /* U+03A7 "Χ" */ + 0x9, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xf9, 0x0, 0xd, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x2f, 0xfc, 0x0, 0x0, 0x3f, 0xfe, 0x10, 0x0, + 0x0, 0xc, 0xff, 0x20, 0x0, 0x0, 0x7f, 0xfa, + 0x0, 0x0, 0x9, 0xff, 0x50, 0x0, 0x0, 0x0, + 0xbf, 0xf6, 0x0, 0x5, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xf2, 0x2, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xc0, 0xcf, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xcf, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xdf, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xb1, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xe1, + 0x6, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xf4, 0x0, 0xa, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x8f, 0xf8, 0x0, 0x0, 0x1e, 0xff, 0x40, 0x0, + 0x0, 0x4f, 0xfc, 0x0, 0x0, 0x0, 0x4f, 0xfe, + 0x10, 0x0, 0x1e, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x8f, 0xfb, 0x0, 0xb, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf6, 0x8, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf2, + + /* U+03A8 "Ψ" */ + 0x4f, 0xf6, 0x0, 0x0, 0xa, 0xff, 0x0, 0x0, + 0x0, 0xff, 0xa4, 0xff, 0x60, 0x0, 0x0, 0xaf, + 0xf0, 0x0, 0x0, 0xf, 0xfa, 0x4f, 0xf6, 0x0, + 0x0, 0xa, 0xff, 0x0, 0x0, 0x0, 0xff, 0xa4, + 0xff, 0x60, 0x0, 0x0, 0xaf, 0xf0, 0x0, 0x0, + 0xf, 0xfa, 0x4f, 0xf6, 0x0, 0x0, 0xa, 0xff, + 0x0, 0x0, 0x0, 0xff, 0xa4, 0xff, 0x60, 0x0, + 0x0, 0xaf, 0xf0, 0x0, 0x0, 0xf, 0xfa, 0x3f, + 0xf7, 0x0, 0x0, 0xa, 0xff, 0x0, 0x0, 0x1, + 0xff, 0x92, 0xff, 0x90, 0x0, 0x0, 0xaf, 0xf0, + 0x0, 0x0, 0x3f, 0xf8, 0xf, 0xfd, 0x0, 0x0, + 0xa, 0xff, 0x0, 0x0, 0x8, 0xff, 0x50, 0xaf, + 0xf5, 0x0, 0x0, 0xaf, 0xf0, 0x0, 0x1, 0xef, + 0xf1, 0x3, 0xff, 0xf5, 0x0, 0xa, 0xff, 0x0, + 0x2, 0xcf, 0xf9, 0x0, 0x7, 0xff, 0xfd, 0x85, + 0xbf, 0xf5, 0x7a, 0xff, 0xfd, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x10, + 0x0, 0x0, 0x1, 0x7b, 0xef, 0xff, 0xff, 0xec, + 0x82, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf0, 0x0, 0x0, + 0x0, 0x0, + + /* U+03A9 "Ω" */ + 0x0, 0x0, 0x2, 0x8c, 0xff, 0xfd, 0x93, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfa, 0x64, + 0x6a, 0xff, 0xfc, 0x0, 0x0, 0xa, 0xff, 0xc2, + 0x0, 0x0, 0x2, 0xdf, 0xf9, 0x0, 0x4, 0xff, + 0xd1, 0x0, 0x0, 0x0, 0x1, 0xef, 0xf4, 0x0, + 0xcf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xb0, 0x1f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x14, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf4, 0x6f, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0x57, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf6, 0x6f, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0x53, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xf2, 0xe, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xfe, 0x0, 0x8f, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0x80, 0x1, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xe1, 0x0, 0x5, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x3f, 0xf4, 0x0, + 0x0, 0x7, 0xfe, 0x30, 0x0, 0x0, 0x3e, 0xf6, + 0x0, 0x4, 0x66, 0x6c, 0xff, 0x90, 0x0, 0x9f, + 0xfc, 0x66, 0x63, 0xaf, 0xff, 0xff, 0xff, 0x20, + 0x2f, 0xff, 0xff, 0xff, 0xaa, 0xff, 0xff, 0xff, + 0xf2, 0x2, 0xff, 0xff, 0xff, 0xfa, + + /* U+03AA "Ϊ" */ + 0xf, 0xf9, 0x0, 0xef, 0xa0, 0xff, 0x90, 0xe, + 0xfa, 0xd, 0xd7, 0x0, 0xcd, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0x30, 0x0, 0x0, + 0x7f, 0xf3, 0x0, 0x0, 0x7, 0xff, 0x30, 0x0, + 0x0, 0x7f, 0xf3, 0x0, 0x0, 0x7, 0xff, 0x30, + 0x0, 0x0, 0x7f, 0xf3, 0x0, 0x0, 0x7, 0xff, + 0x30, 0x0, 0x0, 0x7f, 0xf3, 0x0, 0x0, 0x7, + 0xff, 0x30, 0x0, 0x0, 0x7f, 0xf3, 0x0, 0x0, + 0x7, 0xff, 0x30, 0x0, 0x0, 0x7f, 0xf3, 0x0, + 0x0, 0x7, 0xff, 0x30, 0x0, 0x0, 0x7f, 0xf3, + 0x0, 0x0, 0x7, 0xff, 0x30, 0x0, 0x0, 0x7f, + 0xf3, 0x0, 0x0, 0x7, 0xff, 0x30, 0x0, 0x0, + 0x7f, 0xf3, 0x0, 0x0, 0x7, 0xff, 0x30, 0x0, + 0x0, 0x7f, 0xf3, 0x0, + + /* U+03AB "Ϋ" */ + 0x0, 0x0, 0x9, 0xff, 0x0, 0x7f, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf0, 0x7, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x7, 0xdd, 0x0, + 0x6d, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0x20, + 0xdf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0x60, 0x4, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xb0, 0x0, 0x9, 0xff, 0x90, 0x0, 0x0, + 0x0, 0xef, 0xe1, 0x0, 0x0, 0xd, 0xff, 0x40, + 0x0, 0x0, 0x9f, 0xf5, 0x0, 0x0, 0x0, 0x3f, + 0xfd, 0x0, 0x0, 0x4f, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xf8, 0x0, 0xd, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf3, 0x8, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xc2, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xef, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf7, + 0x0, 0x0, 0x0, 0x0, + + /* U+03AC "ά" */ + 0x0, 0x0, 0x0, 0x1, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6e, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6c, 0xff, 0xd7, 0x0, 0x8f, 0xf0, + 0x0, 0x1c, 0xff, 0xff, 0xff, 0xc0, 0xcf, 0xb0, + 0x0, 0xbf, 0xfb, 0x31, 0x3a, 0xfb, 0xff, 0x70, + 0x4, 0xff, 0xb0, 0x0, 0x0, 0xbf, 0xff, 0x30, + 0xa, 0xff, 0x20, 0x0, 0x0, 0x2f, 0xff, 0x0, + 0xd, 0xfe, 0x0, 0x0, 0x0, 0xd, 0xfc, 0x0, + 0xf, 0xfb, 0x0, 0x0, 0x0, 0xb, 0xf9, 0x0, + 0xf, 0xfb, 0x0, 0x0, 0x0, 0xb, 0xf6, 0x0, + 0xf, 0xfb, 0x0, 0x0, 0x0, 0xb, 0xf8, 0x0, + 0xd, 0xfe, 0x0, 0x0, 0x0, 0xe, 0xfb, 0x0, + 0x9, 0xff, 0x20, 0x0, 0x0, 0x3f, 0xff, 0x0, + 0x3, 0xff, 0xb0, 0x0, 0x0, 0xcf, 0xff, 0x20, + 0x0, 0xaf, 0xfa, 0x21, 0x4c, 0xf9, 0xff, 0x60, + 0x0, 0xc, 0xff, 0xff, 0xff, 0xc0, 0xdf, 0xa0, + 0x0, 0x0, 0x6c, 0xff, 0xd7, 0x0, 0x7f, 0xf0, + + /* U+03AD "έ" */ + 0x0, 0x0, 0x9, 0xff, 0x70, 0x0, 0x0, 0x1, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x8f, 0xd0, 0x0, + 0x0, 0x0, 0xd, 0xd2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3a, 0xef, 0xeb, 0x50, 0x0, 0x4f, + 0xff, 0xff, 0xff, 0xb1, 0xe, 0xfd, 0x42, 0x4a, + 0xf9, 0x3, 0xff, 0x30, 0x0, 0x2, 0x0, 0x3f, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xe5, 0x10, + 0x0, 0x0, 0x1, 0xcf, 0xff, 0xf0, 0x0, 0x0, + 0x3d, 0xff, 0xff, 0x0, 0x0, 0x1f, 0xfe, 0x52, + 0x10, 0x0, 0x7, 0xff, 0x30, 0x0, 0x0, 0x0, + 0xaf, 0xf0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x20, + 0x0, 0x5, 0x80, 0x3f, 0xfd, 0x41, 0x3a, 0xff, + 0x80, 0x8f, 0xff, 0xff, 0xff, 0xc1, 0x0, 0x5b, + 0xef, 0xeb, 0x50, 0x0, + + /* U+03AE "ή" */ + 0x0, 0x0, 0x0, 0x3e, 0xeb, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0x20, 0x0, 0x0, 0x0, 0x2, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x9f, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xf1, 0x18, 0xdf, 0xeb, 0x40, 0x1, 0xff, 0x4e, + 0xff, 0xff, 0xff, 0x70, 0x1f, 0xfe, 0xf8, 0x33, + 0x6f, 0xff, 0x21, 0xff, 0xf4, 0x0, 0x0, 0x4f, + 0xf7, 0x1f, 0xfb, 0x0, 0x0, 0x0, 0xef, 0xa1, + 0xff, 0x70, 0x0, 0x0, 0xc, 0xfa, 0x1f, 0xf6, + 0x0, 0x0, 0x0, 0xcf, 0xb1, 0xff, 0x50, 0x0, + 0x0, 0xc, 0xfb, 0x1f, 0xf5, 0x0, 0x0, 0x0, + 0xcf, 0xb1, 0xff, 0x50, 0x0, 0x0, 0xc, 0xfb, + 0x1f, 0xf5, 0x0, 0x0, 0x0, 0xcf, 0xb1, 0xff, + 0x50, 0x0, 0x0, 0xc, 0xfb, 0x1f, 0xf5, 0x0, + 0x0, 0x0, 0xcf, 0xb1, 0xff, 0x50, 0x0, 0x0, + 0xc, 0xfb, 0x1f, 0xf5, 0x0, 0x0, 0x0, 0xcf, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xb0, + + /* U+03AF "ί" */ + 0x0, 0xce, 0xd2, 0x5, 0xff, 0x70, 0xd, 0xfa, + 0x0, 0x4f, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xf5, 0x0, 0x2f, 0xf5, 0x0, + 0x2f, 0xf5, 0x0, 0x2f, 0xf5, 0x0, 0x2f, 0xf5, + 0x0, 0x2f, 0xf5, 0x0, 0x2f, 0xf5, 0x0, 0x2f, + 0xf5, 0x0, 0x2f, 0xf5, 0x0, 0x2f, 0xf5, 0x0, + 0x2f, 0xf5, 0x0, 0x2f, 0xf5, 0x0, 0x2f, 0xf5, + 0x0, 0x2f, 0xf5, 0x0, 0x2f, 0xf5, 0x0, + + /* U+03B0 "ΰ" */ + 0x0, 0x0, 0x0, 0x7f, 0xd0, 0x0, 0x0, 0x4f, + 0xf1, 0xe, 0xf3, 0xbf, 0xa0, 0x4, 0xff, 0x17, + 0xf6, 0xb, 0xfa, 0x0, 0x3a, 0xa0, 0x88, 0x0, + 0x7a, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xf5, 0x0, 0x0, 0x0, 0xff, 0x72, 0xff, 0x50, + 0x0, 0x0, 0xf, 0xf7, 0x2f, 0xf5, 0x0, 0x0, + 0x0, 0xff, 0x72, 0xff, 0x50, 0x0, 0x0, 0xf, + 0xf7, 0x2f, 0xf5, 0x0, 0x0, 0x0, 0xff, 0x72, + 0xff, 0x50, 0x0, 0x0, 0xf, 0xf7, 0x2f, 0xf5, + 0x0, 0x0, 0x0, 0xff, 0x72, 0xff, 0x50, 0x0, + 0x0, 0xf, 0xf7, 0x2f, 0xf5, 0x0, 0x0, 0x0, + 0xff, 0x71, 0xff, 0x60, 0x0, 0x0, 0xf, 0xf6, + 0xf, 0xf8, 0x0, 0x0, 0x3, 0xff, 0x40, 0xcf, + 0xe1, 0x0, 0x0, 0xaf, 0xf1, 0x4, 0xff, 0xd5, + 0x13, 0xaf, 0xf8, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x3, 0xad, 0xfe, 0xb5, 0x0, + 0x0, + + /* U+03B1 "α" */ + 0x0, 0x0, 0x6c, 0xff, 0xd7, 0x0, 0x8f, 0xf0, + 0x0, 0x1c, 0xff, 0xff, 0xff, 0xc0, 0xcf, 0xb0, + 0x0, 0xbf, 0xfb, 0x31, 0x3a, 0xfb, 0xff, 0x70, + 0x4, 0xff, 0xb0, 0x0, 0x0, 0xbf, 0xff, 0x30, + 0xa, 0xff, 0x20, 0x0, 0x0, 0x2f, 0xff, 0x0, + 0xd, 0xfe, 0x0, 0x0, 0x0, 0xd, 0xfc, 0x0, + 0xf, 0xfb, 0x0, 0x0, 0x0, 0xb, 0xf9, 0x0, + 0xf, 0xfb, 0x0, 0x0, 0x0, 0xb, 0xf6, 0x0, + 0xf, 0xfb, 0x0, 0x0, 0x0, 0xb, 0xf8, 0x0, + 0xd, 0xfe, 0x0, 0x0, 0x0, 0xe, 0xfb, 0x0, + 0x9, 0xff, 0x20, 0x0, 0x0, 0x3f, 0xff, 0x0, + 0x3, 0xff, 0xb0, 0x0, 0x0, 0xcf, 0xff, 0x20, + 0x0, 0xaf, 0xfa, 0x21, 0x4c, 0xf9, 0xff, 0x60, + 0x0, 0xc, 0xff, 0xff, 0xff, 0xc0, 0xdf, 0xa0, + 0x0, 0x0, 0x6c, 0xff, 0xd7, 0x0, 0x7f, 0xf0, + + /* U+03B2 "β" */ + 0x0, 0x1, 0x7c, 0xef, 0xd9, 0x10, 0x0, 0x0, + 0x4e, 0xff, 0xff, 0xff, 0xe3, 0x0, 0x2, 0xff, + 0xd5, 0x11, 0x6e, 0xfe, 0x0, 0x9, 0xfd, 0x0, + 0x0, 0x3, 0xff, 0x60, 0xe, 0xf7, 0x0, 0x0, + 0x0, 0xcf, 0x90, 0xf, 0xf6, 0x0, 0x0, 0x0, + 0xbf, 0x80, 0x1f, 0xf5, 0x0, 0x0, 0x1, 0xff, + 0x40, 0x1f, 0xf5, 0x0, 0x0, 0x4d, 0xf9, 0x0, + 0x1f, 0xf5, 0x6, 0xdf, 0xfc, 0x50, 0x0, 0x1f, + 0xf5, 0x7, 0xff, 0xfe, 0xa3, 0x0, 0x1f, 0xf5, + 0x0, 0x1, 0x5d, 0xff, 0x50, 0x1f, 0xf5, 0x0, + 0x0, 0x0, 0xcf, 0xf2, 0x1f, 0xf5, 0x0, 0x0, + 0x0, 0x2f, 0xf9, 0x1f, 0xf6, 0x0, 0x0, 0x0, + 0xd, 0xfc, 0x1f, 0xf8, 0x0, 0x0, 0x0, 0xc, + 0xfc, 0x1f, 0xfc, 0x0, 0x0, 0x0, 0xe, 0xfa, + 0x1f, 0xff, 0x40, 0x0, 0x0, 0x6f, 0xf5, 0x1f, + 0xff, 0xf6, 0x0, 0x5, 0xff, 0xc0, 0x1f, 0xf7, + 0xef, 0xfd, 0xef, 0xfd, 0x10, 0x1f, 0xf5, 0x8, + 0xdf, 0xfd, 0x70, 0x0, 0x1f, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03B3 "γ" */ + 0x7f, 0xf1, 0x0, 0x0, 0x0, 0xf, 0xf7, 0x2f, + 0xf6, 0x0, 0x0, 0x0, 0x6f, 0xf1, 0xc, 0xfc, + 0x0, 0x0, 0x0, 0xbf, 0xc0, 0x6, 0xff, 0x10, + 0x0, 0x1, 0xff, 0x60, 0x1, 0xff, 0x70, 0x0, + 0x6, 0xff, 0x10, 0x0, 0xbf, 0xc0, 0x0, 0xc, + 0xfb, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x1f, 0xf5, + 0x0, 0x0, 0xf, 0xf7, 0x0, 0x7f, 0xf0, 0x0, + 0x0, 0xa, 0xfc, 0x0, 0xdf, 0x90, 0x0, 0x0, + 0x4, 0xff, 0x22, 0xff, 0x40, 0x0, 0x0, 0x0, + 0xef, 0x78, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xdd, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0x30, 0x0, 0x0, + + /* U+03B4 "δ" */ + 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x9, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xef, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xaf, 0xa1, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xcf, 0xff, 0xe4, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xfe, 0xff, 0xf7, 0x0, 0x0, 0xa, 0xff, 0x91, + 0x0, 0x4d, 0xf9, 0x0, 0x4, 0xff, 0xa0, 0x0, + 0x0, 0x1e, 0xf7, 0x0, 0xaf, 0xf1, 0x0, 0x0, + 0x0, 0x7f, 0xf1, 0xd, 0xfb, 0x0, 0x0, 0x0, + 0x2, 0xff, 0x50, 0xff, 0x90, 0x0, 0x0, 0x0, + 0xf, 0xf8, 0xf, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0xff, 0x90, 0xff, 0x90, 0x0, 0x0, 0x0, 0xf, + 0xf8, 0xc, 0xfc, 0x0, 0x0, 0x0, 0x2, 0xff, + 0x70, 0x7f, 0xf2, 0x0, 0x0, 0x0, 0x7f, 0xf3, + 0x1, 0xff, 0xc0, 0x0, 0x0, 0x2f, 0xfc, 0x0, + 0x7, 0xff, 0xd4, 0x12, 0x7f, 0xff, 0x30, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xfe, 0x40, 0x0, 0x0, + 0x4, 0xae, 0xff, 0xc7, 0x10, 0x0, + + /* U+03B5 "ε" */ + 0x0, 0x3a, 0xef, 0xeb, 0x50, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0xb1, 0xe, 0xfd, 0x42, 0x4a, 0xf9, + 0x3, 0xff, 0x30, 0x0, 0x2, 0x0, 0x3f, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xe5, 0x10, 0x0, + 0x0, 0x1, 0xcf, 0xff, 0xf0, 0x0, 0x0, 0x3d, + 0xff, 0xff, 0x0, 0x0, 0x1f, 0xfe, 0x52, 0x10, + 0x0, 0x7, 0xff, 0x30, 0x0, 0x0, 0x0, 0xaf, + 0xf0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x20, 0x0, + 0x5, 0x80, 0x3f, 0xfd, 0x41, 0x3a, 0xff, 0x80, + 0x8f, 0xff, 0xff, 0xff, 0xc1, 0x0, 0x5b, 0xef, + 0xeb, 0x50, 0x0, + + /* U+03B6 "ζ" */ + 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, 0x10, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x1, 0xbf, 0xc2, 0x0, 0x0, 0x0, 0x2, 0xdf, + 0xa0, 0x0, 0x0, 0x0, 0x2, 0xef, 0x80, 0x0, + 0x0, 0x0, 0x1, 0xef, 0x90, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0x90, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xfe, 0x63, 0x10, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xfb, 0x30, 0x0, 0x0, 0x7d, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x5b, 0xff, 0x40, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x5, 0xeb, 0x50, + 0x0, + + /* U+03B7 "η" */ + 0x1f, 0xf1, 0x18, 0xdf, 0xeb, 0x40, 0x1, 0xff, + 0x4e, 0xff, 0xff, 0xff, 0x70, 0x1f, 0xfe, 0xf8, + 0x33, 0x6f, 0xff, 0x21, 0xff, 0xf4, 0x0, 0x0, + 0x4f, 0xf7, 0x1f, 0xfb, 0x0, 0x0, 0x0, 0xef, + 0xa1, 0xff, 0x70, 0x0, 0x0, 0xc, 0xfa, 0x1f, + 0xf6, 0x0, 0x0, 0x0, 0xcf, 0xb1, 0xff, 0x50, + 0x0, 0x0, 0xc, 0xfb, 0x1f, 0xf5, 0x0, 0x0, + 0x0, 0xcf, 0xb1, 0xff, 0x50, 0x0, 0x0, 0xc, + 0xfb, 0x1f, 0xf5, 0x0, 0x0, 0x0, 0xcf, 0xb1, + 0xff, 0x50, 0x0, 0x0, 0xc, 0xfb, 0x1f, 0xf5, + 0x0, 0x0, 0x0, 0xcf, 0xb1, 0xff, 0x50, 0x0, + 0x0, 0xc, 0xfb, 0x1f, 0xf5, 0x0, 0x0, 0x0, + 0xcf, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xb0, + + /* U+03B8 "θ" */ + 0x0, 0x2, 0x9d, 0xfe, 0xc6, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x1, 0xff, + 0xd4, 0x12, 0x8f, 0xfa, 0x0, 0x9, 0xff, 0x20, + 0x0, 0x7, 0xff, 0x30, 0xf, 0xf8, 0x0, 0x0, + 0x0, 0xef, 0x90, 0x4f, 0xf3, 0x0, 0x0, 0x0, + 0xaf, 0xd0, 0x7f, 0xf0, 0x0, 0x0, 0x0, 0x7f, + 0xf0, 0x9f, 0xe0, 0x0, 0x0, 0x0, 0x5f, 0xf3, + 0xaf, 0xd0, 0x0, 0x0, 0x0, 0x4f, 0xf4, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf4, 0xaf, 0xd0, 0x0, + 0x0, 0x0, 0x4f, 0xf4, 0x9f, 0xe0, 0x0, 0x0, + 0x0, 0x4f, 0xf3, 0x7f, 0xf0, 0x0, 0x0, 0x0, + 0x7f, 0xf0, 0x4f, 0xf3, 0x0, 0x0, 0x0, 0xaf, + 0xd0, 0xf, 0xf8, 0x0, 0x0, 0x0, 0xef, 0x90, + 0x9, 0xff, 0x20, 0x0, 0x7, 0xff, 0x30, 0x1, + 0xff, 0xe5, 0x12, 0x8f, 0xfa, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x2, 0x9d, + 0xfe, 0xc6, 0x0, 0x0, + + /* U+03B9 "ι" */ + 0x2f, 0xf5, 0x2f, 0xf5, 0x2f, 0xf5, 0x2f, 0xf5, + 0x2f, 0xf5, 0x2f, 0xf5, 0x2f, 0xf5, 0x2f, 0xf5, + 0x2f, 0xf5, 0x2f, 0xf5, 0x2f, 0xf5, 0x2f, 0xf5, + 0x2f, 0xf5, 0x2f, 0xf5, 0x2f, 0xf5, + + /* U+03BA "κ" */ + 0x2f, 0xf4, 0x0, 0x0, 0x5f, 0xfd, 0x12, 0xff, + 0x40, 0x0, 0x5f, 0xfc, 0x10, 0x2f, 0xf4, 0x0, + 0x5f, 0xfc, 0x0, 0x2, 0xff, 0x40, 0x5f, 0xfb, + 0x0, 0x0, 0x2f, 0xf4, 0x5f, 0xfb, 0x0, 0x0, + 0x2, 0xff, 0x9f, 0xfa, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xfd, 0x10, 0x0, 0x0, 0x2f, 0xf9, 0x5f, 0xfb, + 0x0, 0x0, 0x2, 0xff, 0x40, 0x9f, 0xf8, 0x0, + 0x0, 0x2f, 0xf4, 0x0, 0xbf, 0xf5, 0x0, 0x2, + 0xff, 0x40, 0x1, 0xef, 0xf3, 0x0, 0x2f, 0xf4, + 0x0, 0x3, 0xff, 0xe1, 0x2, 0xff, 0x40, 0x0, + 0x5, 0xff, 0xc0, 0x2f, 0xf4, 0x0, 0x0, 0x8, + 0xff, 0x90, + + /* U+03BB "λ" */ + 0x0, 0x4, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xcd, 0xfb, 0x0, 0x0, 0x0, 0x1, + 0xff, 0x77, 0xff, 0x10, 0x0, 0x0, 0x7, 0xff, + 0x11, 0xff, 0x70, 0x0, 0x0, 0xd, 0xfb, 0x0, + 0xbf, 0xd0, 0x0, 0x0, 0x3f, 0xf5, 0x0, 0x5f, + 0xf3, 0x0, 0x0, 0x9f, 0xe0, 0x0, 0xf, 0xf9, + 0x0, 0x0, 0xef, 0x90, 0x0, 0x9, 0xfe, 0x0, + 0x5, 0xff, 0x30, 0x0, 0x4, 0xff, 0x50, 0xb, + 0xfd, 0x0, 0x0, 0x0, 0xdf, 0xb0, 0x1f, 0xf7, + 0x0, 0x0, 0x0, 0x8f, 0xf1, 0x7f, 0xf1, 0x0, + 0x0, 0x0, 0x2f, 0xf7, + + /* U+03BC "μ" */ + 0x1f, 0xf5, 0x0, 0x0, 0x0, 0xcf, 0xa1, 0xff, + 0x50, 0x0, 0x0, 0xc, 0xfa, 0x1f, 0xf5, 0x0, + 0x0, 0x0, 0xcf, 0xa1, 0xff, 0x50, 0x0, 0x0, + 0xc, 0xfa, 0x1f, 0xf5, 0x0, 0x0, 0x0, 0xcf, + 0xa1, 0xff, 0x50, 0x0, 0x0, 0xc, 0xfa, 0x1f, + 0xf5, 0x0, 0x0, 0x0, 0xcf, 0xa1, 0xff, 0x50, + 0x0, 0x0, 0xc, 0xfa, 0x1f, 0xf6, 0x0, 0x0, + 0x0, 0xdf, 0xa1, 0xff, 0x70, 0x0, 0x0, 0xe, + 0xfa, 0x1f, 0xfb, 0x0, 0x0, 0x2, 0xff, 0xa1, + 0xff, 0xf4, 0x0, 0x0, 0xbf, 0xfa, 0x1f, 0xff, + 0xf8, 0x46, 0xcf, 0xff, 0xa1, 0xff, 0xbf, 0xff, + 0xff, 0xea, 0xfa, 0x1f, 0xf5, 0x5c, 0xfe, 0xa1, + 0x9f, 0xa1, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+03BD "ν" */ + 0x7f, 0xf2, 0x0, 0x0, 0x0, 0x1f, 0xf7, 0x1f, + 0xf7, 0x0, 0x0, 0x0, 0x6f, 0xf2, 0xb, 0xfd, + 0x0, 0x0, 0x0, 0xbf, 0xc0, 0x5, 0xff, 0x20, + 0x0, 0x1, 0xff, 0x60, 0x0, 0xff, 0x80, 0x0, + 0x7, 0xff, 0x0, 0x0, 0x9f, 0xd0, 0x0, 0xc, + 0xfa, 0x0, 0x0, 0x4f, 0xf3, 0x0, 0x2f, 0xf4, + 0x0, 0x0, 0xe, 0xf9, 0x0, 0x8f, 0xe0, 0x0, + 0x0, 0x8, 0xfe, 0x0, 0xdf, 0x80, 0x0, 0x0, + 0x2, 0xff, 0x33, 0xff, 0x30, 0x0, 0x0, 0x0, + 0xcf, 0x88, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xdd, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0x50, 0x0, + 0x0, + + /* U+03BE "ξ" */ + 0x0, 0x4, 0xad, 0xff, 0xf9, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xf9, 0x0, 0x7, 0xff, 0xa4, 0x10, + 0x0, 0x0, 0xd, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xf5, 0x0, 0x0, 0x0, 0x0, 0xc, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0x93, 0x11, + 0x10, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x2, 0xcf, 0xff, 0xf6, 0x0, 0x0, 0x3d, + 0xfe, 0x73, 0x10, 0x0, 0x3, 0xef, 0xb0, 0x0, + 0x0, 0x0, 0xd, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0x82, 0x0, 0x0, 0x0, 0x3, 0xef, 0xff, 0xfc, + 0x92, 0x0, 0x0, 0x19, 0xef, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x1, 0x48, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xe0, 0x0, 0x0, 0x0, 0x59, 0xff, 0x80, + 0x0, 0x0, 0x1, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x5, 0xec, 0x60, 0x0, + + /* U+03BF "ο" */ + 0x0, 0x0, 0x39, 0xdf, 0xfc, 0x81, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0xe3, 0x0, 0x0, + 0x9f, 0xfc, 0x41, 0x26, 0xef, 0xf2, 0x0, 0x3f, + 0xfb, 0x0, 0x0, 0x2, 0xff, 0xc0, 0x9, 0xff, + 0x10, 0x0, 0x0, 0x8, 0xff, 0x20, 0xdf, 0xb0, + 0x0, 0x0, 0x0, 0x2f, 0xf6, 0xf, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0xff, 0x80, 0xff, 0x80, 0x0, + 0x0, 0x0, 0xf, 0xf9, 0xf, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0xff, 0x80, 0xdf, 0xb0, 0x0, 0x0, + 0x0, 0x2f, 0xf6, 0x9, 0xff, 0x10, 0x0, 0x0, + 0x8, 0xff, 0x20, 0x3f, 0xfa, 0x0, 0x0, 0x2, + 0xff, 0xb0, 0x0, 0x9f, 0xfc, 0x41, 0x26, 0xef, + 0xf2, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xe4, + 0x0, 0x0, 0x0, 0x3a, 0xef, 0xfc, 0x81, 0x0, + 0x0, + + /* U+03C0 "π" */ + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xb6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x9f, 0xe0, 0x0, + 0x0, 0xf, 0xf6, 0x0, 0x0, 0x0, 0x9, 0xfe, + 0x0, 0x0, 0x0, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x9f, 0xe0, 0x0, 0x0, 0xf, 0xf6, 0x0, 0x0, + 0x0, 0x9, 0xfe, 0x0, 0x0, 0x0, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x9f, 0xe0, 0x0, 0x0, 0xf, + 0xf6, 0x0, 0x0, 0x0, 0x9, 0xfe, 0x0, 0x0, + 0x0, 0xff, 0x60, 0x0, 0x0, 0x0, 0x9f, 0xe0, + 0x0, 0x0, 0xf, 0xf6, 0x0, 0x0, 0x0, 0x9, + 0xfe, 0x0, 0x0, 0x0, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x9f, 0xe0, 0x0, 0x0, 0xf, 0xf6, 0x0, + 0x0, 0x0, 0x9, 0xfe, 0x0, 0x0, 0x0, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x9f, 0xe0, 0x0, 0x0, + 0xf, 0xf6, 0x0, 0x0, 0x0, 0x9, 0xfe, 0x0, + 0x0, 0x0, 0xff, 0x60, 0x0, 0x0, 0x0, 0x9f, + 0xe0, 0x0, 0x0, 0xf, 0xf6, 0x0, 0x0, + + /* U+03C1 "ρ" */ + 0x0, 0x0, 0x7c, 0xff, 0xd9, 0x20, 0x0, 0x0, + 0x2e, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0xdf, + 0xf7, 0x21, 0x4c, 0xff, 0x60, 0x6, 0xff, 0x50, + 0x0, 0x0, 0xbf, 0xf1, 0xb, 0xfc, 0x0, 0x0, + 0x0, 0x2f, 0xf7, 0xf, 0xf7, 0x0, 0x0, 0x0, + 0xc, 0xfb, 0x1f, 0xf5, 0x0, 0x0, 0x0, 0xa, + 0xfd, 0x2f, 0xf4, 0x0, 0x0, 0x0, 0x9, 0xfe, + 0x3f, 0xf5, 0x0, 0x0, 0x0, 0xa, 0xfd, 0x3f, + 0xf7, 0x0, 0x0, 0x0, 0xc, 0xfb, 0x3f, 0xfb, + 0x0, 0x0, 0x0, 0x1f, 0xf7, 0x3f, 0xff, 0x40, + 0x0, 0x0, 0xbf, 0xf1, 0x3f, 0xff, 0xf7, 0x21, + 0x4b, 0xff, 0x70, 0x3f, 0xfb, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x3f, 0xf4, 0x3a, 0xef, 0xea, 0x40, + 0x0, 0x3f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+03C2 "ς" */ + 0x0, 0x0, 0x6, 0xbe, 0xff, 0xda, 0x10, 0x0, + 0x5e, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x7f, 0xfc, + 0x52, 0x11, 0x45, 0x0, 0x4f, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xfe, 0x83, 0x0, 0x0, 0x0, 0x3, 0xdf, 0xff, + 0xfe, 0x80, 0x0, 0x0, 0x0, 0x4a, 0xef, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x2b, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0x70, 0x0, 0x0, 0x26, + 0x58, 0xff, 0xf1, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x9e, 0xfe, 0x92, 0x0, + 0x0, + + /* U+03C3 "σ" */ + 0x0, 0x0, 0x3a, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0x0, 0xaf, 0xfb, 0x31, 0x26, 0xef, 0xf2, + 0x0, 0x0, 0x3f, 0xfa, 0x0, 0x0, 0x3, 0xff, + 0xb0, 0x0, 0xa, 0xff, 0x0, 0x0, 0x0, 0x9, + 0xff, 0x20, 0x0, 0xef, 0xa0, 0x0, 0x0, 0x0, + 0x3f, 0xf5, 0x0, 0xf, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0xff, 0x70, 0x0, 0xff, 0x70, 0x0, 0x0, + 0x0, 0xf, 0xf8, 0x0, 0xf, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0xff, 0x70, 0x0, 0xef, 0xa0, 0x0, + 0x0, 0x0, 0x3f, 0xf5, 0x0, 0xa, 0xff, 0x0, + 0x0, 0x0, 0x8, 0xff, 0x10, 0x0, 0x3f, 0xf9, + 0x0, 0x0, 0x3, 0xff, 0xa0, 0x0, 0x0, 0xaf, + 0xfb, 0x31, 0x27, 0xff, 0xe2, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xff, 0xe3, 0x0, 0x0, 0x0, + 0x0, 0x4a, 0xef, 0xfc, 0x70, 0x0, 0x0, 0x0, + + /* U+03C4 "τ" */ + 0x6f, 0xff, 0xff, 0xff, 0xff, 0x66, 0xff, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x8f, 0xe0, 0x0, + 0x0, 0x0, 0x8, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xe0, 0x0, 0x0, 0x0, 0x8, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xe0, 0x0, 0x0, 0x0, + 0x8, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xe0, + 0x0, 0x0, 0x0, 0x8, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xe0, 0x0, 0x0, 0x0, 0x8, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xe0, 0x0, 0x0, + 0x0, 0x8, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xe0, 0x0, 0x0, + + /* U+03C5 "υ" */ + 0x2f, 0xf5, 0x0, 0x0, 0x0, 0xff, 0x72, 0xff, + 0x50, 0x0, 0x0, 0xf, 0xf7, 0x2f, 0xf5, 0x0, + 0x0, 0x0, 0xff, 0x72, 0xff, 0x50, 0x0, 0x0, + 0xf, 0xf7, 0x2f, 0xf5, 0x0, 0x0, 0x0, 0xff, + 0x72, 0xff, 0x50, 0x0, 0x0, 0xf, 0xf7, 0x2f, + 0xf5, 0x0, 0x0, 0x0, 0xff, 0x72, 0xff, 0x50, + 0x0, 0x0, 0xf, 0xf7, 0x2f, 0xf5, 0x0, 0x0, + 0x0, 0xff, 0x71, 0xff, 0x60, 0x0, 0x0, 0xf, + 0xf6, 0xf, 0xf8, 0x0, 0x0, 0x3, 0xff, 0x40, + 0xcf, 0xe1, 0x0, 0x0, 0xaf, 0xf1, 0x4, 0xff, + 0xd5, 0x13, 0xaf, 0xf8, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x3, 0xad, 0xfe, 0xb5, + 0x0, 0x0, + + /* U+03C6 "φ" */ + 0x0, 0x0, 0x6c, 0xa0, 0x1a, 0xef, 0xd8, 0x10, + 0x0, 0x0, 0xb, 0xff, 0x70, 0xbf, 0xff, 0xff, + 0xe2, 0x0, 0x0, 0xaf, 0xf9, 0x10, 0xff, 0xc1, + 0x3d, 0xfd, 0x0, 0x3, 0xff, 0x70, 0x0, 0xff, + 0x70, 0x2, 0xff, 0x60, 0xa, 0xfe, 0x0, 0x0, + 0xff, 0x60, 0x0, 0xaf, 0xc0, 0xd, 0xfa, 0x0, + 0x0, 0xff, 0x60, 0x0, 0x7f, 0xf0, 0xf, 0xf9, + 0x0, 0x0, 0xff, 0x60, 0x0, 0x6f, 0xf2, 0xf, + 0xf8, 0x0, 0x0, 0xff, 0x60, 0x0, 0x7f, 0xf1, + 0xe, 0xfa, 0x0, 0x0, 0xff, 0x60, 0x0, 0x9f, + 0xf0, 0xa, 0xff, 0x0, 0x0, 0xff, 0x60, 0x0, + 0xef, 0xb0, 0x5, 0xff, 0x70, 0x0, 0xff, 0x60, + 0x6, 0xff, 0x40, 0x0, 0xcf, 0xf4, 0x0, 0xff, + 0x60, 0x4f, 0xfb, 0x0, 0x0, 0x2e, 0xff, 0xa4, + 0xff, 0x99, 0xff, 0xd1, 0x0, 0x0, 0x2, 0xdf, + 0xff, 0xff, 0xff, 0xfb, 0x10, 0x0, 0x0, 0x0, + 0x6, 0xcf, 0xff, 0xfa, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0x60, 0x0, 0x0, 0x0, + + /* U+03C7 "χ" */ + 0x1f, 0xf9, 0x0, 0x0, 0x0, 0xc, 0xfe, 0x0, + 0x9f, 0xf1, 0x0, 0x0, 0x4, 0xff, 0x60, 0x2, + 0xff, 0x80, 0x0, 0x0, 0xcf, 0xd0, 0x0, 0x9, + 0xff, 0x0, 0x0, 0x4f, 0xf5, 0x0, 0x0, 0x2f, + 0xf7, 0x0, 0xc, 0xfd, 0x0, 0x0, 0x0, 0x9f, + 0xe0, 0x3, 0xff, 0x50, 0x0, 0x0, 0x2, 0xff, + 0x60, 0xbf, 0xc0, 0x0, 0x0, 0x0, 0xa, 0xfe, + 0x3f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xfe, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xfb, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xfb, 0x1f, 0xf7, 0x0, + 0x0, 0x0, 0x5, 0xff, 0x30, 0x8f, 0xf1, 0x0, + 0x0, 0x0, 0xdf, 0xb0, 0x1, 0xff, 0x80, 0x0, + 0x0, 0x6f, 0xf3, 0x0, 0x9, 0xff, 0x10, 0x0, + 0xe, 0xfb, 0x0, 0x0, 0x1f, 0xf9, 0x0, 0x7, + 0xff, 0x30, 0x0, 0x0, 0x9f, 0xf2, 0x0, 0xef, + 0xb0, 0x0, 0x0, 0x1, 0xff, 0xa0, 0x8f, 0xf3, + 0x0, 0x0, 0x0, 0x9, 0xff, 0x20, + + /* U+03C8 "ψ" */ + 0x5f, 0xf1, 0x0, 0x4, 0xff, 0x30, 0x0, 0x2f, + 0xf4, 0x5f, 0xf1, 0x0, 0x4, 0xff, 0x30, 0x0, + 0x2f, 0xf4, 0x5f, 0xf1, 0x0, 0x4, 0xff, 0x30, + 0x0, 0x2f, 0xf4, 0x5f, 0xf1, 0x0, 0x4, 0xff, + 0x30, 0x0, 0x2f, 0xf4, 0x5f, 0xf1, 0x0, 0x4, + 0xff, 0x30, 0x0, 0x2f, 0xf4, 0x5f, 0xf1, 0x0, + 0x4, 0xff, 0x30, 0x0, 0x2f, 0xf4, 0x5f, 0xf1, + 0x0, 0x4, 0xff, 0x30, 0x0, 0x2f, 0xf4, 0x5f, + 0xf1, 0x0, 0x4, 0xff, 0x30, 0x0, 0x2f, 0xf4, + 0x4f, 0xf2, 0x0, 0x4, 0xff, 0x30, 0x0, 0x3f, + 0xf3, 0x3f, 0xf4, 0x0, 0x4, 0xff, 0x30, 0x0, + 0x5f, 0xf2, 0x1f, 0xf8, 0x0, 0x4, 0xff, 0x30, + 0x0, 0x9f, 0xf0, 0xb, 0xff, 0x20, 0x4, 0xff, + 0x30, 0x3, 0xff, 0xb0, 0x2, 0xff, 0xf8, 0x35, + 0xff, 0x53, 0x8f, 0xff, 0x30, 0x0, 0x4e, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe4, 0x0, 0x0, 0x1, + 0x7c, 0xef, 0xff, 0xfe, 0xc7, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0x30, 0x0, 0x0, 0x0, + + /* U+03C9 "ω" */ + 0x0, 0xef, 0x80, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xfc, 0x0, 0x6, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0x30, 0xc, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xa0, 0x2f, 0xf6, + 0x0, 0x0, 0x14, 0x40, 0x0, 0x0, 0x8f, 0xf0, + 0x6f, 0xf2, 0x0, 0x0, 0x4f, 0xf2, 0x0, 0x0, + 0x4f, 0xf4, 0xaf, 0xe0, 0x0, 0x0, 0x4f, 0xf2, + 0x0, 0x0, 0x1f, 0xf7, 0xbf, 0xc0, 0x0, 0x0, + 0x4f, 0xf2, 0x0, 0x0, 0xe, 0xf9, 0xcf, 0xb0, + 0x0, 0x0, 0x4f, 0xf2, 0x0, 0x0, 0xd, 0xfa, + 0xcf, 0xc0, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, + 0xe, 0xf9, 0xaf, 0xd0, 0x0, 0x0, 0x5f, 0xf3, + 0x0, 0x0, 0xf, 0xf8, 0x7f, 0xf2, 0x0, 0x0, + 0x8f, 0xf6, 0x0, 0x0, 0x4f, 0xf5, 0x2f, 0xf8, + 0x0, 0x0, 0xdf, 0xfc, 0x0, 0x0, 0xbf, 0xf0, + 0xa, 0xff, 0x60, 0x1b, 0xf8, 0xaf, 0x91, 0x8, + 0xff, 0x80, 0x1, 0xdf, 0xff, 0xff, 0xc0, 0x1d, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x8, 0xef, 0xd8, + 0x0, 0x1, 0x9e, 0xfd, 0x70, 0x0, + + /* U+03CA "ϊ" */ + 0xcf, 0xd0, 0xa, 0xfe, 0xcf, 0xd0, 0xa, 0xfe, + 0x9d, 0xa0, 0x8, 0xdc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xf5, 0x0, + 0x0, 0x2f, 0xf5, 0x0, 0x0, 0x2f, 0xf5, 0x0, + 0x0, 0x2f, 0xf5, 0x0, 0x0, 0x2f, 0xf5, 0x0, + 0x0, 0x2f, 0xf5, 0x0, 0x0, 0x2f, 0xf5, 0x0, + 0x0, 0x2f, 0xf5, 0x0, 0x0, 0x2f, 0xf5, 0x0, + 0x0, 0x2f, 0xf5, 0x0, 0x0, 0x2f, 0xf5, 0x0, + 0x0, 0x2f, 0xf5, 0x0, 0x0, 0x2f, 0xf5, 0x0, + 0x0, 0x2f, 0xf5, 0x0, 0x0, 0x2f, 0xf5, 0x0, + + /* U+03CB "ϋ" */ + 0x0, 0x2f, 0xf6, 0x1, 0xff, 0x80, 0x0, 0x2, + 0xff, 0x60, 0x1f, 0xf8, 0x0, 0x0, 0x2d, 0xd5, + 0x1, 0xdd, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0x50, 0x0, 0x0, 0xf, 0xf7, 0x2f, + 0xf5, 0x0, 0x0, 0x0, 0xff, 0x72, 0xff, 0x50, + 0x0, 0x0, 0xf, 0xf7, 0x2f, 0xf5, 0x0, 0x0, + 0x0, 0xff, 0x72, 0xff, 0x50, 0x0, 0x0, 0xf, + 0xf7, 0x2f, 0xf5, 0x0, 0x0, 0x0, 0xff, 0x72, + 0xff, 0x50, 0x0, 0x0, 0xf, 0xf7, 0x2f, 0xf5, + 0x0, 0x0, 0x0, 0xff, 0x72, 0xff, 0x50, 0x0, + 0x0, 0xf, 0xf7, 0x1f, 0xf6, 0x0, 0x0, 0x0, + 0xff, 0x60, 0xff, 0x80, 0x0, 0x0, 0x3f, 0xf4, + 0xc, 0xfe, 0x10, 0x0, 0xa, 0xff, 0x10, 0x4f, + 0xfd, 0x51, 0x3a, 0xff, 0x80, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x3a, 0xdf, 0xeb, + 0x50, 0x0, + + /* U+03CC "ό" */ + 0x0, 0x0, 0x0, 0x4, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xe7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x39, + 0xdf, 0xfc, 0x81, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xe3, 0x0, 0x0, 0x9f, 0xfc, 0x41, + 0x26, 0xef, 0xf2, 0x0, 0x3f, 0xfb, 0x0, 0x0, + 0x2, 0xff, 0xc0, 0x9, 0xff, 0x10, 0x0, 0x0, + 0x8, 0xff, 0x20, 0xdf, 0xb0, 0x0, 0x0, 0x0, + 0x2f, 0xf6, 0xf, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0xff, 0x80, 0xff, 0x80, 0x0, 0x0, 0x0, 0xf, + 0xf9, 0xf, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xff, + 0x80, 0xdf, 0xb0, 0x0, 0x0, 0x0, 0x2f, 0xf6, + 0x9, 0xff, 0x10, 0x0, 0x0, 0x8, 0xff, 0x20, + 0x3f, 0xfa, 0x0, 0x0, 0x2, 0xff, 0xb0, 0x0, + 0x9f, 0xfc, 0x41, 0x26, 0xef, 0xf2, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xe4, 0x0, 0x0, 0x0, + 0x3a, 0xef, 0xfc, 0x81, 0x0, 0x0, + + /* U+03CD "ύ" */ + 0x0, 0x0, 0x0, 0x6f, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x5, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0xae, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xf5, 0x0, 0x0, 0x0, 0xff, 0x72, 0xff, 0x50, + 0x0, 0x0, 0xf, 0xf7, 0x2f, 0xf5, 0x0, 0x0, + 0x0, 0xff, 0x72, 0xff, 0x50, 0x0, 0x0, 0xf, + 0xf7, 0x2f, 0xf5, 0x0, 0x0, 0x0, 0xff, 0x72, + 0xff, 0x50, 0x0, 0x0, 0xf, 0xf7, 0x2f, 0xf5, + 0x0, 0x0, 0x0, 0xff, 0x72, 0xff, 0x50, 0x0, + 0x0, 0xf, 0xf7, 0x2f, 0xf5, 0x0, 0x0, 0x0, + 0xff, 0x71, 0xff, 0x60, 0x0, 0x0, 0xf, 0xf6, + 0xf, 0xf8, 0x0, 0x0, 0x3, 0xff, 0x40, 0xcf, + 0xe1, 0x0, 0x0, 0xaf, 0xf1, 0x4, 0xff, 0xd5, + 0x13, 0xaf, 0xf8, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x3, 0xad, 0xfe, 0xb5, 0x0, + 0x0, + + /* U+03CE "ώ" */ + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6e, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0x80, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xfc, 0x0, 0x6, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0x30, + 0xc, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xa0, 0x2f, 0xf6, 0x0, 0x0, 0x14, 0x40, + 0x0, 0x0, 0x8f, 0xf0, 0x6f, 0xf2, 0x0, 0x0, + 0x4f, 0xf2, 0x0, 0x0, 0x4f, 0xf4, 0xaf, 0xe0, + 0x0, 0x0, 0x4f, 0xf2, 0x0, 0x0, 0x1f, 0xf7, + 0xbf, 0xc0, 0x0, 0x0, 0x4f, 0xf2, 0x0, 0x0, + 0xe, 0xf9, 0xcf, 0xb0, 0x0, 0x0, 0x4f, 0xf2, + 0x0, 0x0, 0xd, 0xfa, 0xcf, 0xc0, 0x0, 0x0, + 0x5f, 0xf2, 0x0, 0x0, 0xe, 0xf9, 0xaf, 0xd0, + 0x0, 0x0, 0x5f, 0xf3, 0x0, 0x0, 0xf, 0xf8, + 0x7f, 0xf2, 0x0, 0x0, 0x8f, 0xf6, 0x0, 0x0, + 0x4f, 0xf5, 0x2f, 0xf8, 0x0, 0x0, 0xdf, 0xfc, + 0x0, 0x0, 0xbf, 0xf0, 0xa, 0xff, 0x60, 0x1b, + 0xf8, 0xaf, 0x91, 0x8, 0xff, 0x80, 0x1, 0xdf, + 0xff, 0xff, 0xc0, 0x1d, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x8, 0xef, 0xd8, 0x0, 0x1, 0x9e, 0xfd, + 0x70, 0x0, + + /* U+03F4 "ϴ" */ + 0x0, 0x0, 0x7, 0xfe, 0x0, 0x3, 0xaa, 0x0, + 0xef, 0x47, 0xa6, 0x4f, 0xf1, 0x6f, 0x90, 0xbf, + 0xa4, 0xff, 0x1d, 0xd0, 0xb, 0xfa +}; + + +/*--------------------- + * GLYPH DESCRIPTION + *--------------------*/ + +static const lv_font_fmt_txt_glyph_dsc_t glyph_dsc[] = { + {.bitmap_index = 0, .adv_w = 0, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0} /* id = 0 reserved */, + {.bitmap_index = 0, .adv_w = 124, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 0, .adv_w = 125, .box_w = 4, .box_h = 20, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 40, .adv_w = 159, .box_w = 8, .box_h = 8, .ofs_x = 1, .ofs_y = 12}, + {.bitmap_index = 72, .adv_w = 249, .box_w = 16, .box_h = 20, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 232, .adv_w = 249, .box_w = 14, .box_h = 26, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 414, .adv_w = 398, .box_w = 23, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 644, .adv_w = 299, .box_w = 18, .box_h = 21, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 833, .adv_w = 85, .box_w = 4, .box_h = 8, .ofs_x = 1, .ofs_y = 12}, + {.bitmap_index = 849, .adv_w = 149, .box_w = 8, .box_h = 26, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 953, .adv_w = 149, .box_w = 7, .box_h = 26, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 1044, .adv_w = 174, .box_w = 10, .box_h = 9, .ofs_x = 0, .ofs_y = 11}, + {.bitmap_index = 1089, .adv_w = 262, .box_w = 14, .box_h = 14, .ofs_x = 1, .ofs_y = 3}, + {.bitmap_index = 1187, .adv_w = 125, .box_w = 4, .box_h = 7, .ofs_x = 2, .ofs_y = -4}, + {.bitmap_index = 1201, .adv_w = 149, .box_w = 9, .box_h = 3, .ofs_x = 0, .ofs_y = 6}, + {.bitmap_index = 1215, .adv_w = 125, .box_w = 4, .box_h = 3, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 1221, .adv_w = 124, .box_w = 8, .box_h = 20, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1301, .adv_w = 249, .box_w = 14, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1441, .adv_w = 249, .box_w = 8, .box_h = 20, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 1521, .adv_w = 249, .box_w = 15, .box_h = 20, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1671, .adv_w = 249, .box_w = 14, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1811, .adv_w = 249, .box_w = 15, .box_h = 20, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1961, .adv_w = 249, .box_w = 14, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2101, .adv_w = 249, .box_w = 14, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2241, .adv_w = 249, .box_w = 14, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2381, .adv_w = 249, .box_w = 14, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2521, .adv_w = 249, .box_w = 14, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2661, .adv_w = 125, .box_w = 4, .box_h = 15, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 2691, .adv_w = 125, .box_w = 4, .box_h = 19, .ofs_x = 2, .ofs_y = -4}, + {.bitmap_index = 2729, .adv_w = 262, .box_w = 14, .box_h = 14, .ofs_x = 1, .ofs_y = 3}, + {.bitmap_index = 2827, .adv_w = 262, .box_w = 14, .box_h = 9, .ofs_x = 1, .ofs_y = 6}, + {.bitmap_index = 2890, .adv_w = 262, .box_w = 14, .box_h = 14, .ofs_x = 1, .ofs_y = 3}, + {.bitmap_index = 2988, .adv_w = 249, .box_w = 14, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3128, .adv_w = 455, .box_w = 27, .box_h = 26, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 3479, .adv_w = 299, .box_w = 20, .box_h = 20, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 3679, .adv_w = 299, .box_w = 16, .box_h = 20, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 3839, .adv_w = 324, .box_w = 19, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4029, .adv_w = 324, .box_w = 17, .box_h = 20, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 4199, .adv_w = 299, .box_w = 16, .box_h = 20, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 4359, .adv_w = 274, .box_w = 14, .box_h = 20, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 4499, .adv_w = 348, .box_w = 19, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4689, .adv_w = 324, .box_w = 16, .box_h = 20, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 4849, .adv_w = 125, .box_w = 4, .box_h = 20, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 4889, .adv_w = 224, .box_w = 12, .box_h = 20, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5009, .adv_w = 299, .box_w = 17, .box_h = 20, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 5179, .adv_w = 249, .box_w = 13, .box_h = 20, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 5309, .adv_w = 373, .box_w = 20, .box_h = 20, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 5509, .adv_w = 324, .box_w = 16, .box_h = 20, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 5669, .adv_w = 348, .box_w = 20, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 5869, .adv_w = 299, .box_w = 16, .box_h = 20, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 6029, .adv_w = 348, .box_w = 20, .box_h = 22, .ofs_x = 1, .ofs_y = -2}, + {.bitmap_index = 6249, .adv_w = 324, .box_w = 18, .box_h = 20, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 6429, .adv_w = 299, .box_w = 17, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 6599, .adv_w = 274, .box_w = 17, .box_h = 20, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6769, .adv_w = 324, .box_w = 16, .box_h = 20, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 6929, .adv_w = 299, .box_w = 19, .box_h = 20, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7119, .adv_w = 423, .box_w = 27, .box_h = 20, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7389, .adv_w = 299, .box_w = 19, .box_h = 20, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7579, .adv_w = 299, .box_w = 19, .box_h = 20, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7769, .adv_w = 274, .box_w = 17, .box_h = 20, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7939, .adv_w = 125, .box_w = 7, .box_h = 26, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 8030, .adv_w = 124, .box_w = 8, .box_h = 20, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 8110, .adv_w = 125, .box_w = 6, .box_h = 26, .ofs_x = 0, .ofs_y = -6}, + {.bitmap_index = 8188, .adv_w = 210, .box_w = 13, .box_h = 11, .ofs_x = 0, .ofs_y = 10}, + {.bitmap_index = 8260, .adv_w = 249, .box_w = 17, .box_h = 2, .ofs_x = -1, .ofs_y = -6}, + {.bitmap_index = 8277, .adv_w = 149, .box_w = 6, .box_h = 4, .ofs_x = 1, .ofs_y = 17}, + {.bitmap_index = 8289, .adv_w = 249, .box_w = 14, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 8394, .adv_w = 249, .box_w = 14, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 8534, .adv_w = 224, .box_w = 13, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 8632, .adv_w = 249, .box_w = 13, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 8762, .adv_w = 249, .box_w = 14, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 8867, .adv_w = 125, .box_w = 9, .box_h = 20, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 8957, .adv_w = 249, .box_w = 14, .box_h = 21, .ofs_x = 0, .ofs_y = -6}, + {.bitmap_index = 9104, .adv_w = 249, .box_w = 13, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 9234, .adv_w = 100, .box_w = 4, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 9274, .adv_w = 100, .box_w = 7, .box_h = 26, .ofs_x = -2, .ofs_y = -6}, + {.bitmap_index = 9365, .adv_w = 224, .box_w = 13, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 9495, .adv_w = 100, .box_w = 4, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 9535, .adv_w = 373, .box_w = 21, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 9693, .adv_w = 249, .box_w = 13, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 9791, .adv_w = 249, .box_w = 15, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 9904, .adv_w = 249, .box_w = 14, .box_h = 21, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 10051, .adv_w = 249, .box_w = 13, .box_h = 21, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 10188, .adv_w = 149, .box_w = 9, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 10256, .adv_w = 224, .box_w = 13, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 10354, .adv_w = 125, .box_w = 8, .box_h = 21, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 10438, .adv_w = 249, .box_w = 13, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 10536, .adv_w = 224, .box_w = 14, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 10641, .adv_w = 324, .box_w = 21, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 10799, .adv_w = 224, .box_w = 14, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 10904, .adv_w = 224, .box_w = 14, .box_h = 21, .ofs_x = 0, .ofs_y = -6}, + {.bitmap_index = 11051, .adv_w = 224, .box_w = 14, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 11156, .adv_w = 149, .box_w = 9, .box_h = 26, .ofs_x = 0, .ofs_y = -6}, + {.bitmap_index = 11273, .adv_w = 116, .box_w = 3, .box_h = 26, .ofs_x = 2, .ofs_y = -6}, + {.bitmap_index = 11312, .adv_w = 149, .box_w = 9, .box_h = 26, .ofs_x = 0, .ofs_y = -6}, + {.bitmap_index = 11429, .adv_w = 262, .box_w = 15, .box_h = 6, .ofs_x = 1, .ofs_y = 7}, + {.bitmap_index = 11474, .adv_w = 124, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 11474, .adv_w = 249, .box_w = 15, .box_h = 21, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 11632, .adv_w = 249, .box_w = 14, .box_h = 14, .ofs_x = 1, .ofs_y = 3}, + {.bitmap_index = 11730, .adv_w = 249, .box_w = 16, .box_h = 20, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 11890, .adv_w = 117, .box_w = 3, .box_h = 26, .ofs_x = 2, .ofs_y = -6}, + {.bitmap_index = 11929, .adv_w = 249, .box_w = 14, .box_h = 26, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 12111, .adv_w = 149, .box_w = 9, .box_h = 3, .ofs_x = 0, .ofs_y = 18}, + {.bitmap_index = 12125, .adv_w = 330, .box_w = 21, .box_h = 21, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 12346, .adv_w = 168, .box_w = 11, .box_h = 10, .ofs_x = 0, .ofs_y = 10}, + {.bitmap_index = 12401, .adv_w = 249, .box_w = 13, .box_h = 13, .ofs_x = 1, .ofs_y = 1}, + {.bitmap_index = 12486, .adv_w = 262, .box_w = 14, .box_h = 9, .ofs_x = 1, .ofs_y = 6}, + {.bitmap_index = 12549, .adv_w = 149, .box_w = 9, .box_h = 3, .ofs_x = 0, .ofs_y = 6}, + {.bitmap_index = 12563, .adv_w = 330, .box_w = 21, .box_h = 21, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 12784, .adv_w = 179, .box_w = 9, .box_h = 9, .ofs_x = 1, .ofs_y = 13}, + {.bitmap_index = 12825, .adv_w = 262, .box_w = 14, .box_h = 17, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 12944, .adv_w = 149, .box_w = 9, .box_h = 10, .ofs_x = 0, .ofs_y = 10}, + {.bitmap_index = 12989, .adv_w = 149, .box_w = 9, .box_h = 10, .ofs_x = 0, .ofs_y = 10}, + {.bitmap_index = 13034, .adv_w = 249, .box_w = 13, .box_h = 21, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 13171, .adv_w = 241, .box_w = 17, .box_h = 26, .ofs_x = -1, .ofs_y = -6}, + {.bitmap_index = 13392, .adv_w = 126, .box_w = 4, .box_h = 3, .ofs_x = 2, .ofs_y = 9}, + {.bitmap_index = 13398, .adv_w = 249, .box_w = 13, .box_h = 13, .ofs_x = 1, .ofs_y = 1}, + {.bitmap_index = 13483, .adv_w = 374, .box_w = 22, .box_h = 22, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 13725, .adv_w = 149, .box_w = 6, .box_h = 4, .ofs_x = 3, .ofs_y = 17}, + {.bitmap_index = 13737, .adv_w = 299, .box_w = 20, .box_h = 20, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 13937, .adv_w = 351, .box_w = 23, .box_h = 20, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 14167, .adv_w = 375, .box_w = 23, .box_h = 20, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 14397, .adv_w = 172, .box_w = 10, .box_h = 20, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 14497, .adv_w = 347, .box_w = 23, .box_h = 20, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 14727, .adv_w = 383, .box_w = 26, .box_h = 20, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 14987, .adv_w = 337, .box_w = 22, .box_h = 20, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 15207, .adv_w = 100, .box_w = 11, .box_h = 21, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 15323, .adv_w = 299, .box_w = 20, .box_h = 20, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 15523, .adv_w = 299, .box_w = 16, .box_h = 20, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 15683, .adv_w = 247, .box_w = 13, .box_h = 20, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 15813, .adv_w = 299, .box_w = 20, .box_h = 20, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 16013, .adv_w = 299, .box_w = 16, .box_h = 20, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 16173, .adv_w = 274, .box_w = 17, .box_h = 20, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 16343, .adv_w = 324, .box_w = 16, .box_h = 20, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 16503, .adv_w = 348, .box_w = 20, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 16703, .adv_w = 125, .box_w = 4, .box_h = 20, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 16743, .adv_w = 299, .box_w = 17, .box_h = 20, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 16913, .adv_w = 299, .box_w = 19, .box_h = 20, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 17103, .adv_w = 373, .box_w = 20, .box_h = 20, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 17303, .adv_w = 324, .box_w = 16, .box_h = 20, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 17463, .adv_w = 291, .box_w = 16, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 17623, .adv_w = 348, .box_w = 20, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 17823, .adv_w = 324, .box_w = 16, .box_h = 20, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 17983, .adv_w = 299, .box_w = 16, .box_h = 20, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 18143, .adv_w = 277, .box_w = 15, .box_h = 20, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 18293, .adv_w = 274, .box_w = 17, .box_h = 20, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 18463, .adv_w = 299, .box_w = 19, .box_h = 20, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 18653, .adv_w = 357, .box_w = 21, .box_h = 22, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 18884, .adv_w = 299, .box_w = 19, .box_h = 20, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 19074, .adv_w = 374, .box_w = 21, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 19284, .adv_w = 335, .box_w = 19, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 19474, .adv_w = 125, .box_w = 9, .box_h = 24, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 19582, .adv_w = 299, .box_w = 19, .box_h = 24, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 19810, .adv_w = 259, .box_w = 16, .box_h = 21, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 19978, .adv_w = 200, .box_w = 11, .box_h = 21, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 20094, .adv_w = 249, .box_w = 13, .box_h = 27, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 20270, .adv_w = 100, .box_w = 6, .box_h = 21, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 20333, .adv_w = 245, .box_w = 13, .box_h = 21, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 20470, .adv_w = 259, .box_w = 16, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 20590, .adv_w = 258, .box_w = 14, .box_h = 26, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 20772, .adv_w = 224, .box_w = 14, .box_h = 21, .ofs_x = 0, .ofs_y = -6}, + {.bitmap_index = 20919, .adv_w = 249, .box_w = 15, .box_h = 20, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 21069, .adv_w = 200, .box_w = 11, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 21152, .adv_w = 198, .box_w = 13, .box_h = 26, .ofs_x = 0, .ofs_y = -6}, + {.bitmap_index = 21321, .adv_w = 249, .box_w = 13, .box_h = 21, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 21458, .adv_w = 249, .box_w = 14, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 21598, .adv_w = 100, .box_w = 4, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 21628, .adv_w = 223, .box_w = 13, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 21726, .adv_w = 224, .box_w = 14, .box_h = 20, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 21866, .adv_w = 249, .box_w = 13, .box_h = 21, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 22003, .adv_w = 224, .box_w = 14, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 22108, .adv_w = 201, .box_w = 12, .box_h = 26, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 22264, .adv_w = 249, .box_w = 15, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 22377, .adv_w = 309, .box_w = 19, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 22520, .adv_w = 255, .box_w = 14, .box_h = 21, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 22667, .adv_w = 216, .box_w = 13, .box_h = 21, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 22804, .adv_w = 277, .box_w = 17, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 22932, .adv_w = 177, .box_w = 11, .box_h = 15, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 23015, .adv_w = 245, .box_w = 13, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 23113, .adv_w = 291, .box_w = 18, .box_h = 21, .ofs_x = 0, .ofs_y = -6}, + {.bitmap_index = 23302, .adv_w = 235, .box_w = 15, .box_h = 21, .ofs_x = 0, .ofs_y = -6}, + {.bitmap_index = 23460, .adv_w = 319, .box_w = 18, .box_h = 21, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 23649, .adv_w = 350, .box_w = 20, .box_h = 15, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 23799, .adv_w = 100, .box_w = 8, .box_h = 20, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 23879, .adv_w = 245, .box_w = 13, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 24009, .adv_w = 249, .box_w = 15, .box_h = 21, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 24167, .adv_w = 245, .box_w = 13, .box_h = 21, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 24304, .adv_w = 350, .box_w = 20, .box_h = 21, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 24514, .adv_w = 149, .box_w = 11, .box_h = 4, .ofs_x = -1, .ofs_y = 17} +}; + +/*--------------------- + * CHARACTER MAPPING + *--------------------*/ + +static const uint8_t glyph_id_ofs_list_1[] = { + 0, 0, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 0, + 13, 14, 15, 16, 0, 17, 18, 19, + 0, 0, 0, 20, 0, 21 +}; + +static const uint8_t glyph_id_ofs_list_2[] = { + 0, 0, 1, 0, 2, 3, 4, 0, + 5 +}; + +/*Collect the unicode lists and glyph_id offsets*/ +static const lv_font_fmt_txt_cmap_t cmaps[] = +{ + { + .range_start = 32, .range_length = 95, .glyph_id_start = 1, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 160, .range_length = 30, .glyph_id_start = 96, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_1, .list_length = 30, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 900, .range_length = 9, .glyph_id_start = 118, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_2, .list_length = 9, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 910, .range_length = 20, .glyph_id_start = 124, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 931, .range_length = 44, .glyph_id_start = 144, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 1012, .range_length = 1, .glyph_id_start = 188, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + } +}; + + + +/*-------------------- + * ALL CUSTOM DATA + *--------------------*/ + +#if LVGL_VERSION_MAJOR == 8 +/*Store all the custom data of the font*/ +static lv_font_fmt_txt_glyph_cache_t cache; +#endif + +#if LVGL_VERSION_MAJOR >= 8 +static const lv_font_fmt_txt_dsc_t font_dsc = { +#else +static lv_font_fmt_txt_dsc_t font_dsc = { +#endif + .glyph_bitmap = glyph_bitmap, + .glyph_dsc = glyph_dsc, + .cmaps = cmaps, + .kern_dsc = NULL, + .kern_scale = 0, + .cmap_num = 6, + .bpp = 4, + .kern_classes = 0, + .bitmap_format = 0, +#if LVGL_VERSION_MAJOR == 8 + .cache = &cache +#endif + +}; + +extern const lv_font_t lv_font_montserrat_28; + + +/*----------------- + * PUBLIC FONT + *----------------*/ + +/*Initialize a public general font descriptor*/ +#if LVGL_VERSION_MAJOR >= 8 +const lv_font_t lv_font_arial_28 = { +#else +lv_font_t lv_font_arial_28 = { +#endif + .get_glyph_dsc = lv_font_get_glyph_dsc_fmt_txt, /*Function pointer to get glyph's data*/ + .get_glyph_bitmap = lv_font_get_bitmap_fmt_txt, /*Function pointer to get glyph's bitmap*/ + .line_height = 30, /*The maximum line height required by the font*/ + .base_line = 6, /*Baseline measured from the bottom of the line*/ +#if !(LVGL_VERSION_MAJOR == 6 && LVGL_VERSION_MINOR == 0) + .subpx = LV_FONT_SUBPX_NONE, +#endif +#if LV_VERSION_CHECK(7, 4, 0) || LVGL_VERSION_MAJOR >= 8 + .underline_position = -3, + .underline_thickness = 2, +#endif + //.static_bitmap = 0, + .dsc = &font_dsc, /*The custom font data. Will be accessed by `get_glyph_bitmap/dsc` */ +#if LV_VERSION_CHECK(8, 2, 0) || LVGL_VERSION_MAJOR >= 9 + .fallback = &lv_font_montserrat_28, +#endif + .user_data = NULL, +}; + + + +#endif /*#if LV_FONT_ARIAL_28*/ diff --git a/src/fonts/lv_font_arial_30.c b/src/fonts/lv_font_arial_30.c new file mode 100644 index 0000000000..501a20a4cf --- /dev/null +++ b/src/fonts/lv_font_arial_30.c @@ -0,0 +1,4317 @@ +/******************************************************************************* + * Size: 30 px + * Bpp: 4 + * Opts: --bpp 4 --size 30 --no-compress --stride 1 --align 1 --font Arial Greek Regular.ttf --range 32-127,160-255,880-1023 --format lvgl -o lv_font_arial_30.c + ******************************************************************************/ + +#ifdef __has_include + #if __has_include("lvgl.h") + #ifndef LV_LVGL_H_INCLUDE_SIMPLE + #define LV_LVGL_H_INCLUDE_SIMPLE + #endif + #endif +#endif + +#ifdef LV_LVGL_H_INCLUDE_SIMPLE + #include "lvgl.h" +#else + #include "lvgl/lvgl.h" +#endif + + + +#ifndef LV_FONT_ARIAL_30 +#define LV_FONT_ARIAL_30 1 +#endif + +#if LV_FONT_ARIAL_30 + +/*----------------- + * BITMAPS + *----------------*/ + +/*Store the image of the glyphs*/ +static LV_ATTRIBUTE_LARGE_CONST const uint8_t glyph_bitmap[] = { + /* U+0020 " " */ + + /* U+0021 "!" */ + 0x7f, 0xfc, 0x7f, 0xfc, 0x7f, 0xfc, 0x7f, 0xfc, + 0x7f, 0xfc, 0x6f, 0xfb, 0x5f, 0xfa, 0x4f, 0xf9, + 0x3f, 0xf8, 0x2f, 0xf7, 0x1f, 0xf6, 0xf, 0xf5, + 0xe, 0xf4, 0xd, 0xf3, 0xc, 0xf2, 0xb, 0xf1, + 0x2, 0x30, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfb, + 0x5f, 0xfb, 0x5f, 0xfb, + + /* U+0022 "\"" */ + 0x9f, 0xf6, 0xc, 0xff, 0x49, 0xff, 0x60, 0xcf, + 0xf4, 0x9f, 0xf6, 0xc, 0xff, 0x49, 0xff, 0x50, + 0xbf, 0xf3, 0x7f, 0xf3, 0x9, 0xff, 0x14, 0xff, + 0x10, 0x6f, 0xe0, 0x1f, 0xe0, 0x3, 0xfc, 0x0, + 0x98, 0x0, 0xa, 0x60, + + /* U+0023 "#" */ + 0x0, 0x0, 0x0, 0xff, 0x20, 0x0, 0x3f, 0xf0, + 0x0, 0x0, 0x0, 0x3f, 0xf0, 0x0, 0x6, 0xfc, + 0x0, 0x0, 0x0, 0x7, 0xfb, 0x0, 0x0, 0xaf, + 0x90, 0x0, 0x0, 0x0, 0xaf, 0x80, 0x0, 0xd, + 0xf5, 0x0, 0x0, 0x0, 0xe, 0xf5, 0x0, 0x1, + 0xff, 0x20, 0x0, 0x0, 0x1, 0xff, 0x10, 0x0, + 0x4f, 0xe0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x5a, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf5, 0x13, 0x33, 0xcf, 0x93, + 0x33, 0x3e, 0xf7, 0x33, 0x10, 0x0, 0xe, 0xf4, + 0x0, 0x1, 0xff, 0x20, 0x0, 0x0, 0x1, 0xff, + 0x10, 0x0, 0x4f, 0xe0, 0x0, 0x0, 0x0, 0x4f, + 0xe0, 0x0, 0x7, 0xfb, 0x0, 0x0, 0x0, 0x7, + 0xfb, 0x0, 0x0, 0xaf, 0x80, 0x0, 0x2, 0x33, + 0xbf, 0xa3, 0x33, 0x3e, 0xf8, 0x33, 0x31, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5a, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0x4f, 0xe0, 0x0, 0x7, 0xfb, 0x0, 0x0, + 0x0, 0x7, 0xfb, 0x0, 0x0, 0xaf, 0x80, 0x0, + 0x0, 0x0, 0xbf, 0x80, 0x0, 0xe, 0xf5, 0x0, + 0x0, 0x0, 0xe, 0xf4, 0x0, 0x1, 0xff, 0x10, + 0x0, 0x0, 0x1, 0xff, 0x10, 0x0, 0x5f, 0xe0, + 0x0, 0x0, 0x0, 0x5f, 0xd0, 0x0, 0x8, 0xfa, + 0x0, 0x0, 0x0, + + /* U+0024 "$" */ + 0x0, 0x0, 0x0, 0x7f, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x4, 0x9d, 0xfa, 0x72, 0x0, 0x0, 0x0, + 0x3d, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x2f, + 0xff, 0xcc, 0xfb, 0xff, 0xf9, 0x0, 0xc, 0xff, + 0x60, 0x7f, 0x12, 0xef, 0xf3, 0x2, 0xff, 0xa0, + 0x7, 0xf1, 0x5, 0xff, 0x90, 0x5f, 0xf5, 0x0, + 0x7f, 0x10, 0xe, 0xc7, 0x6, 0xff, 0x40, 0x7, + 0xf1, 0x0, 0x0, 0x0, 0x4f, 0xf8, 0x0, 0x7f, + 0x10, 0x0, 0x0, 0x0, 0xff, 0xf4, 0x7, 0xf1, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf9, 0x9f, 0x10, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfb, 0x71, + 0x0, 0x0, 0x0, 0x4, 0xbf, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x1a, 0xfe, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0x14, 0xdf, 0xf9, + 0x0, 0x0, 0x0, 0x7, 0xf1, 0x1, 0xef, 0xf0, + 0x0, 0x0, 0x0, 0x7f, 0x10, 0x8, 0xff, 0x46, + 0xab, 0x0, 0x7, 0xf1, 0x0, 0x6f, 0xf5, 0xcf, + 0xf1, 0x0, 0x7f, 0x10, 0x7, 0xff, 0x48, 0xff, + 0x70, 0x7, 0xf1, 0x0, 0xcf, 0xf0, 0x2f, 0xfe, + 0x20, 0x7f, 0x10, 0x7f, 0xfa, 0x0, 0x9f, 0xfe, + 0x69, 0xf5, 0xbf, 0xfe, 0x20, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xfe, 0x30, 0x0, 0x0, 0x3a, 0xef, + 0xff, 0xd8, 0x10, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x38, 0x0, + 0x0, 0x0, 0x0, + + /* U+0025 "%" */ + 0x0, 0x1a, 0xef, 0xd7, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xf1, 0x0, 0x0, 0x1, 0xef, 0xfe, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0xaf, 0x70, 0x0, 0x0, + 0x9, 0xfd, 0x10, 0x3f, 0xf6, 0x0, 0x0, 0x2, + 0xfe, 0x0, 0x0, 0x0, 0xf, 0xf6, 0x0, 0x9, + 0xfb, 0x0, 0x0, 0xb, 0xf6, 0x0, 0x0, 0x0, + 0x2f, 0xf3, 0x0, 0x6, 0xfe, 0x0, 0x0, 0x3f, + 0xd0, 0x0, 0x0, 0x0, 0x2f, 0xf2, 0x0, 0x5, + 0xff, 0x0, 0x0, 0xcf, 0x50, 0x0, 0x0, 0x0, + 0x1f, 0xf3, 0x0, 0x6, 0xfe, 0x0, 0x5, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xf6, 0x0, 0xa, + 0xfb, 0x0, 0xd, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xfe, 0x30, 0x6f, 0xf4, 0x0, 0x6f, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0x80, 0x0, 0xef, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xbc, 0xa4, 0x0, 0x7, 0xfb, 0x0, + 0x7, 0xcc, 0xa3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xf2, 0x0, 0xcf, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xa0, 0x8, + 0xfe, 0x31, 0x7f, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0x20, 0xe, 0xf6, 0x0, 0xc, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xf9, 0x0, 0x2f, + 0xf1, 0x0, 0x8, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xf1, 0x0, 0x4f, 0xf0, 0x0, 0x7, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0x80, 0x0, 0x4f, + 0xf0, 0x0, 0x6, 0xfd, 0x0, 0x0, 0x0, 0x3, + 0xfe, 0x0, 0x0, 0x3f, 0xf1, 0x0, 0x8, 0xfc, + 0x0, 0x0, 0x0, 0xb, 0xf7, 0x0, 0x0, 0xf, + 0xf4, 0x0, 0xb, 0xf8, 0x0, 0x0, 0x0, 0x4f, + 0xe0, 0x0, 0x0, 0x9, 0xfc, 0x10, 0x4f, 0xf2, + 0x0, 0x0, 0x0, 0xcf, 0x60, 0x0, 0x0, 0x1, + 0xdf, 0xfd, 0xff, 0x70, 0x0, 0x0, 0x5, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x19, 0xef, 0xc5, 0x0, + + /* U+0026 "&" */ + 0x0, 0x0, 0x4, 0xbe, 0xfd, 0x81, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xc5, 0x49, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xe1, + 0x0, 0xb, 0xff, 0x20, 0x0, 0x0, 0x0, 0xf, + 0xfb, 0x0, 0x0, 0x7f, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xe0, 0x0, 0x9, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x9, 0xff, 0x80, 0x2, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x54, 0xef, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xdf, 0xff, 0xa1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xe5, 0xdf, 0xfa, 0x0, 0x4, + 0x10, 0x0, 0x9, 0xff, 0xc1, 0x2, 0xff, 0xf7, + 0x1, 0xff, 0xa0, 0x3, 0xff, 0xe0, 0x0, 0x4, + 0xff, 0xf4, 0x7f, 0xf7, 0x0, 0x8f, 0xf6, 0x0, + 0x0, 0x7, 0xff, 0xee, 0xff, 0x20, 0xa, 0xff, + 0x20, 0x0, 0x0, 0xa, 0xff, 0xff, 0xa0, 0x0, + 0xaf, 0xf4, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf2, + 0x0, 0x6, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x90, 0x0, 0xe, 0xff, 0x60, 0x0, 0x1, + 0xcf, 0xff, 0xff, 0x80, 0x0, 0x5f, 0xff, 0xb6, + 0x69, 0xff, 0xfc, 0x6f, 0xff, 0xa0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x6f, 0xfd, 0x10, + 0x0, 0x29, 0xdf, 0xfd, 0x93, 0x0, 0x0, 0x4d, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+0027 "'" */ + 0xaf, 0xf5, 0xaf, 0xf5, 0xaf, 0xf5, 0xaf, 0xf5, + 0x7f, 0xf3, 0x5f, 0xf0, 0x2f, 0xd0, 0xa, 0x70, + + /* U+0028 "(" */ + 0x0, 0x0, 0x5, 0xf9, 0x0, 0x0, 0x1e, 0xf1, + 0x0, 0x0, 0xaf, 0x70, 0x0, 0x4, 0xff, 0x0, + 0x0, 0xc, 0xf8, 0x0, 0x0, 0x4f, 0xf2, 0x0, + 0x0, 0xbf, 0xc0, 0x0, 0x1, 0xff, 0x70, 0x0, + 0x6, 0xff, 0x30, 0x0, 0xa, 0xff, 0x0, 0x0, + 0xd, 0xfc, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, + 0x1f, 0xf9, 0x0, 0x0, 0x2f, 0xf8, 0x0, 0x0, + 0x2f, 0xf8, 0x0, 0x0, 0x1f, 0xf9, 0x0, 0x0, + 0xf, 0xfb, 0x0, 0x0, 0xd, 0xfd, 0x0, 0x0, + 0xa, 0xff, 0x0, 0x0, 0x6, 0xff, 0x30, 0x0, + 0x1, 0xff, 0x70, 0x0, 0x0, 0xbf, 0xc0, 0x0, + 0x0, 0x4f, 0xf2, 0x0, 0x0, 0xd, 0xf8, 0x0, + 0x0, 0x4, 0xff, 0x0, 0x0, 0x0, 0xbf, 0x70, + 0x0, 0x0, 0x1f, 0xf1, 0x0, 0x0, 0x5, 0xf9, + + /* U+0029 ")" */ + 0xaf, 0x50, 0x0, 0x0, 0x1f, 0xe1, 0x0, 0x0, + 0x8, 0xfa, 0x0, 0x0, 0x1, 0xff, 0x40, 0x0, + 0x0, 0x9f, 0xc0, 0x0, 0x0, 0x2f, 0xf4, 0x0, + 0x0, 0xc, 0xfa, 0x0, 0x0, 0x7, 0xff, 0x10, + 0x0, 0x3, 0xff, 0x50, 0x0, 0x0, 0xff, 0x90, + 0x0, 0x0, 0xdf, 0xd0, 0x0, 0x0, 0xbf, 0xf0, + 0x0, 0x0, 0x9f, 0xf1, 0x0, 0x0, 0x8f, 0xf2, + 0x0, 0x0, 0x8f, 0xf2, 0x0, 0x0, 0x9f, 0xf1, + 0x0, 0x0, 0xbf, 0xf0, 0x0, 0x0, 0xdf, 0xd0, + 0x0, 0x0, 0xff, 0xa0, 0x0, 0x3, 0xff, 0x60, + 0x0, 0x8, 0xff, 0x10, 0x0, 0xd, 0xfa, 0x0, + 0x0, 0x2f, 0xf3, 0x0, 0x0, 0x9f, 0xc0, 0x0, + 0x1, 0xff, 0x30, 0x0, 0x8, 0xfa, 0x0, 0x0, + 0x1f, 0xf1, 0x0, 0x0, 0xaf, 0x50, 0x0, 0x0, + + /* U+002A "*" */ + 0x0, 0x3, 0xfd, 0x0, 0x0, 0x0, 0x2, 0xfc, + 0x0, 0x0, 0x57, 0x11, 0xfa, 0x3, 0x91, 0xbf, + 0xf9, 0xfc, 0xcf, 0xf6, 0x6a, 0xef, 0xff, 0xfe, + 0xa4, 0x0, 0xc, 0xff, 0x70, 0x0, 0x0, 0xaf, + 0x9e, 0xf5, 0x0, 0x7, 0xfe, 0x5, 0xff, 0x30, + 0x3, 0xd5, 0x0, 0xaa, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+002B "+" */ + 0x0, 0x0, 0x0, 0x24, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0x0, 0x0, 0x0, 0x27, 0x77, 0x77, + 0xbf, 0xf7, 0x77, 0x77, 0x65, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x7, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf0, 0x0, 0x0, + 0x0, + + /* U+002C "," */ + 0x0, 0x0, 0x6f, 0xf9, 0x6f, 0xf9, 0x6f, 0xf9, + 0x0, 0xf8, 0x2, 0xf6, 0xb, 0xf1, 0x4f, 0x40, + 0x1, 0x0, + + /* U+002D "-" */ + 0xa, 0xaa, 0xaa, 0xaa, 0xa0, 0xf, 0xff, 0xff, + 0xff, 0xf0, 0xf, 0xff, 0xff, 0xff, 0xf0, + + /* U+002E "." */ + 0x0, 0x0, 0x5f, 0xfa, 0x5f, 0xfa, 0x5f, 0xfa, + + /* U+002F "/" */ + 0x0, 0x0, 0x0, 0xef, 0x20, 0x0, 0x0, 0x3f, + 0xe0, 0x0, 0x0, 0x7, 0xf9, 0x0, 0x0, 0x0, + 0xcf, 0x50, 0x0, 0x0, 0x1f, 0xf1, 0x0, 0x0, + 0x5, 0xfc, 0x0, 0x0, 0x0, 0x9f, 0x70, 0x0, + 0x0, 0xe, 0xf3, 0x0, 0x0, 0x2, 0xfe, 0x0, + 0x0, 0x0, 0x7f, 0xa0, 0x0, 0x0, 0xc, 0xf5, + 0x0, 0x0, 0x0, 0xff, 0x10, 0x0, 0x0, 0x5f, + 0xc0, 0x0, 0x0, 0x9, 0xf8, 0x0, 0x0, 0x0, + 0xef, 0x30, 0x0, 0x0, 0x2f, 0xf0, 0x0, 0x0, + 0x7, 0xfa, 0x0, 0x0, 0x0, 0xbf, 0x60, 0x0, + 0x0, 0xf, 0xf1, 0x0, 0x0, 0x4, 0xfd, 0x0, + 0x0, 0x0, 0x9f, 0x80, 0x0, 0x0, 0xd, 0xf4, + 0x0, 0x0, 0x0, + + /* U+0030 "0" */ + 0x0, 0x0, 0x6c, 0xef, 0xda, 0x30, 0x0, 0x0, + 0x1, 0xcf, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0xbf, 0xfb, 0x43, 0x6e, 0xff, 0x50, 0x0, 0x5f, + 0xf9, 0x0, 0x0, 0x1e, 0xfe, 0x0, 0xc, 0xfe, + 0x0, 0x0, 0x0, 0x6f, 0xf6, 0x1, 0xff, 0x90, + 0x0, 0x0, 0x0, 0xff, 0xa0, 0x4f, 0xf5, 0x0, + 0x0, 0x0, 0xc, 0xfe, 0x7, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x9f, 0xf1, 0x9f, 0xf1, 0x0, 0x0, + 0x0, 0x8, 0xff, 0x3a, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xf3, 0xaf, 0xf0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0x4a, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xf4, 0xaf, 0xf0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0x39, 0xff, 0x10, 0x0, 0x0, 0x0, 0x8f, + 0xf3, 0x7f, 0xf3, 0x0, 0x0, 0x0, 0x9, 0xff, + 0x14, 0xff, 0x50, 0x0, 0x0, 0x0, 0xcf, 0xe0, + 0x1f, 0xf9, 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, + 0xcf, 0xf0, 0x0, 0x0, 0x6, 0xff, 0x60, 0x5, + 0xff, 0x90, 0x0, 0x1, 0xef, 0xe0, 0x0, 0xb, + 0xff, 0xb4, 0x36, 0xef, 0xf5, 0x0, 0x0, 0x1c, + 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x6, + 0xce, 0xfe, 0xa3, 0x0, 0x0, + + /* U+0031 "1" */ + 0x0, 0x0, 0x0, 0xcf, 0x30, 0x0, 0x0, 0x7f, + 0xf3, 0x0, 0x0, 0x5f, 0xff, 0x30, 0x0, 0x7f, + 0xff, 0xf3, 0x2, 0xbf, 0xff, 0xff, 0x37, 0xff, + 0xfc, 0x7f, 0xf3, 0xaf, 0xf7, 0x6, 0xff, 0x3a, + 0x91, 0x0, 0x6f, 0xf3, 0x0, 0x0, 0x6, 0xff, + 0x30, 0x0, 0x0, 0x6f, 0xf3, 0x0, 0x0, 0x6, + 0xff, 0x30, 0x0, 0x0, 0x6f, 0xf3, 0x0, 0x0, + 0x6, 0xff, 0x30, 0x0, 0x0, 0x6f, 0xf3, 0x0, + 0x0, 0x6, 0xff, 0x30, 0x0, 0x0, 0x6f, 0xf3, + 0x0, 0x0, 0x6, 0xff, 0x30, 0x0, 0x0, 0x6f, + 0xf3, 0x0, 0x0, 0x6, 0xff, 0x30, 0x0, 0x0, + 0x6f, 0xf3, 0x0, 0x0, 0x6, 0xff, 0x30, 0x0, + 0x0, 0x6f, 0xf3, + + /* U+0032 "2" */ + 0x0, 0x0, 0x17, 0xce, 0xfe, 0xb6, 0x0, 0x0, + 0x0, 0x4, 0xef, 0xff, 0xff, 0xff, 0xd2, 0x0, + 0x0, 0x4f, 0xff, 0x94, 0x35, 0xbf, 0xfd, 0x0, + 0x0, 0xdf, 0xf3, 0x0, 0x0, 0x8, 0xff, 0x80, + 0x3, 0xff, 0x80, 0x0, 0x0, 0x0, 0xef, 0xe0, + 0x7, 0xff, 0x30, 0x0, 0x0, 0x0, 0xaf, 0xf0, + 0x2, 0x68, 0x10, 0x0, 0x0, 0x0, 0xaf, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1c, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xdf, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3e, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xe8, 0x88, 0x88, 0x88, 0x88, 0x81, + 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + + /* U+0033 "3" */ + 0x0, 0x1, 0x8d, 0xff, 0xd9, 0x20, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x3, + 0xff, 0xf8, 0x43, 0x7f, 0xff, 0x50, 0x0, 0xcf, + 0xf3, 0x0, 0x0, 0x2e, 0xfe, 0x0, 0x2f, 0xfa, + 0x0, 0x0, 0x0, 0x8f, 0xf3, 0x3, 0xad, 0x50, + 0x0, 0x0, 0x6, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x8f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xfd, 0x20, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xfc, 0x30, 0x0, 0x0, 0x0, 0x22, 0x2, 0x9f, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0x51, 0x46, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf5, + 0x9f, 0xf3, 0x0, 0x0, 0x0, 0x9, 0xff, 0x35, + 0xff, 0x90, 0x0, 0x0, 0x1, 0xef, 0xf0, 0xe, + 0xff, 0x40, 0x0, 0x0, 0xbf, 0xf8, 0x0, 0x4f, + 0xff, 0x84, 0x36, 0xdf, 0xfc, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x18, + 0xdf, 0xfd, 0xa3, 0x0, 0x0, + + /* U+0034 "4" */ + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xfe, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xf5, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x2, 0xff, 0x64, 0xff, 0x60, 0x0, + 0x0, 0x0, 0xc, 0xfb, 0x4, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x7f, 0xf1, 0x4, 0xff, 0x60, 0x0, + 0x0, 0x2, 0xff, 0x60, 0x4, 0xff, 0x60, 0x0, + 0x0, 0xc, 0xfb, 0x0, 0x4, 0xff, 0x60, 0x0, + 0x0, 0x8f, 0xf1, 0x0, 0x4, 0xff, 0x60, 0x0, + 0x3, 0xff, 0x60, 0x0, 0x4, 0xff, 0x60, 0x0, + 0xd, 0xfb, 0x0, 0x0, 0x4, 0xff, 0x60, 0x0, + 0x7f, 0xf8, 0x77, 0x77, 0x79, 0xff, 0xa7, 0x72, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0x60, 0x0, + + /* U+0035 "5" */ + 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x9f, 0xf8, 0x88, 0x88, 0x88, 0x84, 0x0, 0xc, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf1, 0x8d, + 0xff, 0xc6, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x20, 0x0, 0xef, 0xff, 0xa6, 0x68, + 0xef, 0xfe, 0x10, 0x1f, 0xfe, 0x30, 0x0, 0x0, + 0xbf, 0xfa, 0x0, 0x46, 0x30, 0x0, 0x0, 0x0, + 0xef, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0x82, 0x45, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf6, + 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x9, 0xff, 0x35, + 0xff, 0x90, 0x0, 0x0, 0x1, 0xff, 0xd0, 0xe, + 0xff, 0x40, 0x0, 0x0, 0xbf, 0xf5, 0x0, 0x5f, + 0xff, 0x94, 0x36, 0xdf, 0xfa, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x18, + 0xcf, 0xfe, 0xa4, 0x0, 0x0, + + /* U+0036 "6" */ + 0x0, 0x0, 0x29, 0xdf, 0xfd, 0x81, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xff, 0xe3, 0x0, 0x0, + 0x6f, 0xfd, 0x63, 0x4a, 0xff, 0xe1, 0x0, 0x2f, + 0xfc, 0x10, 0x0, 0x8, 0xff, 0x80, 0x9, 0xff, + 0x20, 0x0, 0x0, 0xe, 0xfd, 0x0, 0xef, 0xa0, + 0x0, 0x0, 0x0, 0x57, 0x60, 0x3f, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0x20, 0x2, + 0x44, 0x20, 0x0, 0x0, 0x9f, 0xf0, 0x3c, 0xff, + 0xff, 0xd4, 0x0, 0xa, 0xfe, 0x4f, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0xbf, 0xff, 0xf8, 0x20, 0x17, + 0xff, 0xf4, 0xb, 0xff, 0xf5, 0x0, 0x0, 0x5, + 0xff, 0xc0, 0xbf, 0xfb, 0x0, 0x0, 0x0, 0xb, + 0xff, 0x2a, 0xff, 0x60, 0x0, 0x0, 0x0, 0x6f, + 0xf5, 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x4, 0xff, + 0x66, 0xff, 0x50, 0x0, 0x0, 0x0, 0x5f, 0xf5, + 0x2f, 0xf9, 0x0, 0x0, 0x0, 0x7, 0xff, 0x30, + 0xdf, 0xe1, 0x0, 0x0, 0x0, 0xdf, 0xe0, 0x6, + 0xff, 0xb0, 0x0, 0x0, 0x8f, 0xf7, 0x0, 0xb, + 0xff, 0xc5, 0x34, 0xbf, 0xfd, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x3, + 0xae, 0xfe, 0xc6, 0x0, 0x0, + + /* U+0037 "7" */ + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x68, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x49, + 0x99, 0x99, 0x99, 0x99, 0xaf, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xf3, 0x0, 0x0, 0x0, 0x0, + + /* U+0038 "8" */ + 0x0, 0x0, 0x7c, 0xef, 0xea, 0x40, 0x0, 0x0, + 0x2, 0xdf, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0xdf, 0xfb, 0x53, 0x6e, 0xff, 0x90, 0x0, 0x7f, + 0xf9, 0x0, 0x0, 0x1d, 0xff, 0x20, 0xb, 0xff, + 0x0, 0x0, 0x0, 0x5f, 0xf6, 0x0, 0xdf, 0xd0, + 0x0, 0x0, 0x3, 0xff, 0x80, 0xb, 0xff, 0x0, + 0x0, 0x0, 0x5f, 0xf6, 0x0, 0x6f, 0xf8, 0x0, + 0x0, 0xd, 0xff, 0x10, 0x0, 0xcf, 0xfb, 0x53, + 0x6d, 0xff, 0x60, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xfd, 0x40, 0x0, 0x0, 0x4c, 0xff, 0xff, 0xff, + 0xfa, 0x10, 0x0, 0x5f, 0xfe, 0x51, 0x2, 0x9f, + 0xfe, 0x10, 0x1f, 0xfe, 0x10, 0x0, 0x0, 0x5f, + 0xfa, 0x6, 0xff, 0x60, 0x0, 0x0, 0x0, 0xbf, + 0xf1, 0xaf, 0xf1, 0x0, 0x0, 0x0, 0x6, 0xff, + 0x4b, 0xff, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf6, + 0x9f, 0xf2, 0x0, 0x0, 0x0, 0x6, 0xff, 0x56, + 0xff, 0x70, 0x0, 0x0, 0x0, 0xcf, 0xf1, 0x1e, + 0xff, 0x40, 0x0, 0x0, 0x7f, 0xfa, 0x0, 0x5f, + 0xff, 0x94, 0x35, 0xbf, 0xfe, 0x10, 0x0, 0x5f, + 0xff, 0xff, 0xff, 0xfc, 0x20, 0x0, 0x0, 0x17, + 0xcf, 0xfe, 0xb5, 0x0, 0x0, + + /* U+0039 "9" */ + 0x0, 0x1, 0x8d, 0xff, 0xd8, 0x10, 0x0, 0x0, + 0x4, 0xef, 0xff, 0xff, 0xff, 0x50, 0x0, 0x2, + 0xff, 0xfa, 0x43, 0x5d, 0xff, 0x50, 0x0, 0xcf, + 0xf7, 0x0, 0x0, 0xc, 0xff, 0x10, 0x3f, 0xfc, + 0x0, 0x0, 0x0, 0x2f, 0xf8, 0x8, 0xff, 0x50, + 0x0, 0x0, 0x0, 0xbf, 0xd0, 0xaf, 0xf1, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xa, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xf3, 0x9f, 0xf2, 0x0, 0x0, + 0x0, 0xa, 0xff, 0x56, 0xff, 0x70, 0x0, 0x0, + 0x0, 0xef, 0xf5, 0x1f, 0xff, 0x20, 0x0, 0x0, + 0x8f, 0xff, 0x60, 0x8f, 0xfe, 0x61, 0x2, 0x9f, + 0xef, 0xf5, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xd5, + 0xff, 0x50, 0x0, 0x7e, 0xff, 0xff, 0x90, 0x4f, + 0xf4, 0x0, 0x0, 0x3, 0x53, 0x0, 0x7, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xe0, + 0x16, 0x82, 0x0, 0x0, 0x0, 0xf, 0xfa, 0x2, + 0xff, 0x80, 0x0, 0x0, 0x7, 0xff, 0x40, 0xd, + 0xff, 0x10, 0x0, 0x3, 0xff, 0xc0, 0x0, 0x4f, + 0xfe, 0x63, 0x48, 0xff, 0xe2, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xff, 0xd3, 0x0, 0x0, 0x0, 0x3a, + 0xef, 0xec, 0x70, 0x0, 0x0, + + /* U+003A ":" */ + 0x5f, 0xfa, 0x5f, 0xfa, 0x5f, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xfa, 0x5f, 0xfa, 0x5f, 0xfa, + + /* U+003B ";" */ + 0x6f, 0xf9, 0x6f, 0xf9, 0x6f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xf9, 0x6f, 0xf9, 0x6f, 0xf9, + 0x0, 0xf8, 0x2, 0xf6, 0xb, 0xf1, 0x4f, 0x40, + 0x1, 0x0, + + /* U+003C "<" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x8e, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x4a, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x6, 0xdf, 0xff, 0xfa, 0x30, 0x0, 0x2, + 0x8e, 0xff, 0xfe, 0x71, 0x0, 0x0, 0x4b, 0xff, + 0xff, 0xb4, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xe8, + 0x20, 0x0, 0x0, 0x0, 0x5, 0xff, 0xe5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, 0xfd, 0x71, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xcf, 0xff, 0xfa, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x3a, 0xff, 0xff, + 0xc5, 0x0, 0x0, 0x0, 0x0, 0x1, 0x8e, 0xff, + 0xfe, 0x82, 0x0, 0x0, 0x0, 0x0, 0x5, 0xcf, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3a, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x60, + + /* U+003D "=" */ + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd5, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x27, + 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x27, 0x77, 0x77, + 0x77, 0x77, 0x77, 0x77, 0x65, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd0, + + /* U+003E ">" */ + 0x49, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xc5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xfe, 0x71, 0x0, 0x0, 0x0, 0x0, 0x16, + 0xdf, 0xff, 0xfa, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x4a, 0xff, 0xff, 0xc5, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x8e, 0xff, 0xfe, 0x81, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xbf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xaf, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x3a, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x6, 0xdf, + 0xff, 0xf9, 0x20, 0x0, 0x2, 0x9f, 0xff, 0xfd, + 0x70, 0x0, 0x0, 0x5b, 0xff, 0xff, 0xb4, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xf9, 0x20, 0x0, 0x0, + 0x0, 0x5, 0xfd, 0x71, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x35, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+003F "?" */ + 0x0, 0x1, 0x7c, 0xef, 0xeb, 0x60, 0x0, 0x0, + 0x4, 0xef, 0xff, 0xff, 0xff, 0xd2, 0x0, 0x3, + 0xff, 0xf9, 0x43, 0x5c, 0xff, 0xe1, 0x0, 0xdf, + 0xf5, 0x0, 0x0, 0x9, 0xff, 0xa0, 0x3f, 0xfb, + 0x0, 0x0, 0x0, 0xd, 0xff, 0x7, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x8f, 0xf3, 0x26, 0x81, 0x0, + 0x0, 0x0, 0x8, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfd, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xfd, 0x10, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbb, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xfd, 0x0, 0x0, 0x0, + + /* U+0040 "@" */ + 0x0, 0x0, 0x0, 0x0, 0x1, 0x6a, 0xce, 0xff, + 0xed, 0xa5, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2a, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x91, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xfa, 0x64, 0x33, 0x46, 0xae, 0xff, + 0xe4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfe, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x6, 0xef, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xbf, 0xf4, 0x0, + 0x0, 0x0, 0x3f, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xe0, 0x0, 0x0, + 0xd, 0xfb, 0x0, 0x0, 0x6, 0xcf, 0xeb, 0x30, + 0x4f, 0xf5, 0x0, 0xef, 0x80, 0x0, 0x7, 0xfe, + 0x10, 0x0, 0x2c, 0xff, 0xff, 0xff, 0x57, 0xff, + 0x10, 0x5, 0xff, 0x0, 0x0, 0xef, 0x60, 0x0, + 0x1d, 0xff, 0x94, 0x38, 0xff, 0xcf, 0xe0, 0x0, + 0xe, 0xf4, 0x0, 0x5f, 0xd0, 0x0, 0xc, 0xff, + 0x50, 0x0, 0x6, 0xff, 0xfb, 0x0, 0x0, 0xaf, + 0x80, 0xa, 0xf8, 0x0, 0x6, 0xff, 0x80, 0x0, + 0x0, 0xd, 0xff, 0x70, 0x0, 0x8, 0xfa, 0x0, + 0xef, 0x40, 0x0, 0xdf, 0xe0, 0x0, 0x0, 0x0, + 0xaf, 0xf4, 0x0, 0x0, 0x7f, 0xb0, 0x1f, 0xf0, + 0x0, 0x4f, 0xf8, 0x0, 0x0, 0x0, 0x8, 0xff, + 0x10, 0x0, 0x8, 0xfa, 0x2, 0xff, 0x0, 0x8, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x9f, 0xd0, 0x0, + 0x0, 0xbf, 0x80, 0x4f, 0xe0, 0x0, 0xaf, 0xf1, + 0x0, 0x0, 0x0, 0xc, 0xfa, 0x0, 0x0, 0xf, + 0xf4, 0x3, 0xfe, 0x0, 0xb, 0xff, 0x0, 0x0, + 0x0, 0x1, 0xff, 0x70, 0x0, 0x6, 0xfe, 0x0, + 0x2f, 0xf0, 0x0, 0xaf, 0xf1, 0x0, 0x0, 0x0, + 0x8f, 0xf4, 0x0, 0x1, 0xef, 0x70, 0x1, 0xff, + 0x20, 0x7, 0xff, 0x50, 0x0, 0x0, 0x3f, 0xff, + 0x0, 0x0, 0xbf, 0xd0, 0x0, 0xd, 0xf7, 0x0, + 0x2f, 0xfd, 0x0, 0x0, 0x2e, 0xff, 0xe0, 0x1, + 0xbf, 0xf2, 0x0, 0x0, 0x8f, 0xc0, 0x0, 0x9f, + 0xfc, 0x43, 0x8f, 0xef, 0xff, 0x99, 0xff, 0xf4, + 0x0, 0x0, 0x3, 0xff, 0x40, 0x0, 0xcf, 0xff, + 0xff, 0xe3, 0xbf, 0xff, 0xff, 0xd3, 0x0, 0x0, + 0x0, 0xa, 0xfe, 0x0, 0x0, 0x7d, 0xfd, 0x81, + 0x2, 0xbf, 0xec, 0x60, 0x0, 0x15, 0x51, 0x0, + 0x2f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1d, 0xfd, 0x0, 0x0, 0x4f, + 0xfd, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4e, 0xff, 0x20, 0x0, 0x0, 0x5f, 0xff, + 0x93, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xbf, + 0xfe, 0x30, 0x0, 0x0, 0x0, 0x2d, 0xff, 0xfd, + 0x96, 0x43, 0x23, 0x46, 0x9d, 0xff, 0xfa, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x26, 0xac, 0xde, 0xff, + 0xec, 0x96, 0x10, 0x0, 0x0, 0x0, + + /* U+0041 "A" */ + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xef, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0x6e, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0x29, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xfd, 0x4, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf8, 0x0, + 0xef, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf3, 0x0, 0x8f, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xd0, 0x0, 0x3f, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0x70, + 0x0, 0xd, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0x10, 0x0, 0x7, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xfb, 0x0, 0x0, 0x1, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf5, + 0x0, 0x0, 0x0, 0xbf, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x9, 0xff, + 0x75, 0x55, 0x55, 0x55, 0x5a, 0xff, 0x70, 0x0, + 0x0, 0xe, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xd0, 0x0, 0x0, 0x5f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf4, 0x0, 0x0, 0xbf, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfa, + 0x0, 0x1, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x10, 0x7, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0x70, 0xd, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xd0, + + /* U+0042 "B" */ + 0xcf, 0xff, 0xff, 0xff, 0xfe, 0xc8, 0x20, 0x0, + 0xc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, + 0x0, 0xcf, 0xf9, 0x88, 0x88, 0x9b, 0xef, 0xff, + 0x50, 0xc, 0xff, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xfe, 0x0, 0xcf, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xf3, 0xc, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0x50, 0xcf, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xf4, 0xc, 0xff, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0x10, 0xcf, 0xf0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0x90, 0xc, 0xff, 0x99, 0x99, + 0x99, 0xae, 0xff, 0xb0, 0x0, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc1, 0x0, 0xc, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0xcf, 0xf0, + 0x0, 0x0, 0x1, 0x38, 0xff, 0xf5, 0xc, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xe0, 0xcf, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0x4c, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf6, + 0xcf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0x5c, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xf2, 0xcf, 0xf0, 0x0, 0x0, 0x0, 0x1, 0xaf, + 0xfc, 0xc, 0xff, 0x98, 0x88, 0x88, 0x9b, 0xff, + 0xff, 0x30, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x40, 0xc, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0xa6, 0x0, 0x0, + + /* U+0043 "C" */ + 0x0, 0x0, 0x0, 0x38, 0xce, 0xff, 0xd9, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x2b, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x10, 0x0, 0x0, 0x4, 0xef, 0xff, + 0xb8, 0x77, 0xaf, 0xff, 0xe2, 0x0, 0x0, 0x2f, + 0xff, 0xa1, 0x0, 0x0, 0x1, 0xcf, 0xfd, 0x0, + 0x0, 0xdf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0x70, 0x6, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xe0, 0xc, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa9, 0x50, 0x1f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5a, 0x61, 0xb, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf4, + 0x5, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xe0, 0x0, 0xcf, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x1d, 0xff, 0x70, 0x0, 0x3f, 0xff, 0xa1, + 0x0, 0x0, 0x3, 0xdf, 0xfd, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xb8, 0x78, 0xcf, 0xff, 0xd2, 0x0, + 0x0, 0x0, 0x3d, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x49, 0xde, 0xff, + 0xd9, 0x30, 0x0, 0x0, + + /* U+0044 "D" */ + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xda, 0x60, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe4, 0x0, 0x0, 0xaf, 0xfa, 0x88, 0x88, 0x9a, + 0xcf, 0xff, 0xf5, 0x0, 0xa, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x19, 0xff, 0xf2, 0x0, 0xaf, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xb0, 0xa, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0x20, 0xaf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xf7, 0xa, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xb0, 0xaf, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xfe, 0xa, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf0, 0xaf, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0x1a, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xf1, 0xaf, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xa, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xe0, 0xaf, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfb, 0xa, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x70, + 0xaf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xf2, 0xa, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xfa, 0x0, 0xaf, 0xf3, 0x0, 0x0, 0x0, + 0x1, 0xaf, 0xff, 0x10, 0xa, 0xff, 0xa8, 0x88, + 0x89, 0xad, 0xff, 0xff, 0x40, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x30, 0x0, 0xa, + 0xff, 0xff, 0xff, 0xff, 0xec, 0x84, 0x0, 0x0, + 0x0, + + /* U+0045 "E" */ + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe0, 0xaf, 0xfa, 0x88, 0x88, 0x88, 0x88, 0x88, + 0x87, 0xa, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xa8, 0x88, + 0x88, 0x88, 0x88, 0x88, 0x0, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf1, 0xa, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x10, 0xaf, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xa8, 0x88, 0x88, 0x88, 0x88, + 0x88, 0x83, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x6a, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf6, + + /* U+0046 "F" */ + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe9, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x9f, + 0xfa, 0x88, 0x88, 0x88, 0x88, 0x88, 0x79, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xa8, 0x88, 0x88, + 0x88, 0x88, 0x20, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf5, 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x50, 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0047 "G" */ + 0x0, 0x0, 0x0, 0x16, 0xbd, 0xef, 0xec, 0x94, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x20, 0x0, 0x0, 0x1, 0xdf, + 0xff, 0xd9, 0x87, 0x8b, 0xff, 0xff, 0x30, 0x0, + 0x0, 0xdf, 0xfc, 0x30, 0x0, 0x0, 0x1, 0xaf, + 0xfe, 0x0, 0x0, 0xaf, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf7, 0x0, 0x3f, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xd0, 0xa, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0x95, 0x0, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xf8, 0x0, 0x0, 0x0, 0x6, 0x88, + 0x88, 0x88, 0x88, 0x36, 0xff, 0x80, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xf6, 0x5f, 0xf9, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, + 0x63, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xf6, 0xf, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0x60, 0xbf, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf6, + 0x3, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0x60, 0xa, 0xff, 0xd1, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xcf, 0xf6, 0x0, 0xd, 0xff, + 0xe7, 0x0, 0x0, 0x0, 0x28, 0xff, 0xff, 0x50, + 0x0, 0x1c, 0xff, 0xff, 0xca, 0x9b, 0xdf, 0xff, + 0xfe, 0x40, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe7, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x6a, 0xde, 0xfe, 0xd9, 0x50, 0x0, 0x0, + + /* U+0048 "H" */ + 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xf4, 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf4, 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xf4, 0x9f, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf4, 0x9f, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x9f, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x9f, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x9f, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, + 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xf4, 0x9f, 0xfa, 0x88, 0x88, 0x88, 0x88, 0x88, + 0xdf, 0xf4, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf4, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x9f, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x9f, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x9f, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x9f, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, + 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xf4, 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf4, 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xf4, 0x9f, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf4, 0x9f, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x9f, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, + + /* U+0049 "I" */ + 0x4f, 0xf9, 0x4f, 0xf9, 0x4f, 0xf9, 0x4f, 0xf9, + 0x4f, 0xf9, 0x4f, 0xf9, 0x4f, 0xf9, 0x4f, 0xf9, + 0x4f, 0xf9, 0x4f, 0xf9, 0x4f, 0xf9, 0x4f, 0xf9, + 0x4f, 0xf9, 0x4f, 0xf9, 0x4f, 0xf9, 0x4f, 0xf9, + 0x4f, 0xf9, 0x4f, 0xf9, 0x4f, 0xf9, 0x4f, 0xf9, + 0x4f, 0xf9, 0x4f, 0xf9, + + /* U+004A "J" */ + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xa1, 0x9b, 0x60, 0x0, 0x0, 0x3f, 0xfa, + 0x1f, 0xf8, 0x0, 0x0, 0x4, 0xff, 0x90, 0xff, + 0xd0, 0x0, 0x0, 0x7f, 0xf6, 0xb, 0xff, 0x60, + 0x0, 0x2e, 0xff, 0x20, 0x4f, 0xff, 0xc9, 0xbf, + 0xff, 0xb0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xc1, + 0x0, 0x0, 0x4a, 0xef, 0xec, 0x60, 0x0, + + /* U+004B "K" */ + 0xcf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xe2, 0xcf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xfe, 0x20, 0xcf, 0xf0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xe2, 0x0, 0xcf, 0xf0, 0x0, 0x0, 0x0, + 0xaf, 0xfe, 0x20, 0x0, 0xcf, 0xf0, 0x0, 0x0, + 0xa, 0xff, 0xe2, 0x0, 0x0, 0xcf, 0xf0, 0x0, + 0x0, 0xaf, 0xfe, 0x20, 0x0, 0x0, 0xcf, 0xf0, + 0x0, 0xa, 0xff, 0xe2, 0x0, 0x0, 0x0, 0xcf, + 0xf0, 0x0, 0x9f, 0xfd, 0x20, 0x0, 0x0, 0x0, + 0xcf, 0xf0, 0x9, 0xff, 0xd1, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xf0, 0x9f, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xf9, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfd, 0x2e, 0xff, + 0x60, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xd1, 0x5, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0xcf, 0xfd, 0x10, + 0x0, 0xaf, 0xfd, 0x0, 0x0, 0x0, 0xcf, 0xf1, + 0x0, 0x0, 0xe, 0xff, 0x90, 0x0, 0x0, 0xcf, + 0xf0, 0x0, 0x0, 0x4, 0xff, 0xf4, 0x0, 0x0, + 0xcf, 0xf0, 0x0, 0x0, 0x0, 0x9f, 0xfe, 0x10, + 0x0, 0xcf, 0xf0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xb0, 0x0, 0xcf, 0xf0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf7, 0x0, 0xcf, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0x30, 0xcf, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xd0, 0xcf, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf9, + + /* U+004C "L" */ + 0xcf, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf9, 0x88, + 0x88, 0x88, 0x88, 0x85, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfa, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, + + /* U+004D "M" */ + 0xcf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xcc, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xfc, 0xcf, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xcc, + 0xff, 0xef, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xfc, 0xcf, 0xf9, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xfb, 0xff, 0xcc, 0xff, 0x4f, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0xef, 0x5f, 0xfc, 0xcf, + 0xf0, 0xef, 0xa0, 0x0, 0x0, 0x0, 0x4f, 0xf0, + 0xff, 0xcc, 0xff, 0x9, 0xff, 0x0, 0x0, 0x0, + 0x9, 0xfa, 0xf, 0xfc, 0xcf, 0xf0, 0x4f, 0xf4, + 0x0, 0x0, 0x0, 0xef, 0x50, 0xff, 0xcc, 0xff, + 0x0, 0xef, 0xa0, 0x0, 0x0, 0x4f, 0xf0, 0xf, + 0xfc, 0xcf, 0xf0, 0x9, 0xfe, 0x0, 0x0, 0x9, + 0xfa, 0x0, 0xff, 0xcc, 0xff, 0x0, 0x4f, 0xf4, + 0x0, 0x0, 0xef, 0x50, 0xf, 0xfc, 0xcf, 0xf0, + 0x0, 0xef, 0x90, 0x0, 0x4f, 0xf0, 0x0, 0xff, + 0xcc, 0xff, 0x0, 0x9, 0xfe, 0x0, 0x9, 0xfa, + 0x0, 0xf, 0xfc, 0xcf, 0xf0, 0x0, 0x4f, 0xf4, + 0x0, 0xef, 0x40, 0x0, 0xff, 0xcc, 0xff, 0x0, + 0x0, 0xef, 0x90, 0x4f, 0xf0, 0x0, 0xf, 0xfc, + 0xcf, 0xf0, 0x0, 0x9, 0xfe, 0x9, 0xfa, 0x0, + 0x0, 0xff, 0xcc, 0xff, 0x0, 0x0, 0x4f, 0xf3, + 0xef, 0x40, 0x0, 0xf, 0xfc, 0xcf, 0xf0, 0x0, + 0x0, 0xef, 0xcf, 0xe0, 0x0, 0x0, 0xff, 0xcc, + 0xff, 0x0, 0x0, 0xa, 0xff, 0xf9, 0x0, 0x0, + 0xf, 0xfc, 0xcf, 0xf0, 0x0, 0x0, 0x4f, 0xff, + 0x40, 0x0, 0x0, 0xff, 0xcc, 0xff, 0x0, 0x0, + 0x0, 0xff, 0xe0, 0x0, 0x0, 0xf, 0xfc, + + /* U+004E "N" */ + 0xaf, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xf4, 0xaf, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xf4, 0xaf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xf4, 0xaf, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf4, 0xaf, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x7f, 0xf4, 0xaf, 0xf7, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x7f, 0xf4, 0xaf, 0xf1, + 0xbf, 0xf8, 0x0, 0x0, 0x0, 0x7f, 0xf4, 0xaf, + 0xf1, 0x2f, 0xff, 0x30, 0x0, 0x0, 0x7f, 0xf4, + 0xaf, 0xf1, 0x7, 0xff, 0xd0, 0x0, 0x0, 0x7f, + 0xf4, 0xaf, 0xf1, 0x0, 0xcf, 0xf7, 0x0, 0x0, + 0x7f, 0xf4, 0xaf, 0xf1, 0x0, 0x2f, 0xff, 0x20, + 0x0, 0x7f, 0xf4, 0xaf, 0xf1, 0x0, 0x7, 0xff, + 0xc0, 0x0, 0x7f, 0xf4, 0xaf, 0xf1, 0x0, 0x0, + 0xcf, 0xf7, 0x0, 0x7f, 0xf4, 0xaf, 0xf1, 0x0, + 0x0, 0x3f, 0xff, 0x20, 0x7f, 0xf4, 0xaf, 0xf1, + 0x0, 0x0, 0x8, 0xff, 0xb0, 0x7f, 0xf4, 0xaf, + 0xf1, 0x0, 0x0, 0x0, 0xdf, 0xf6, 0x7f, 0xf4, + 0xaf, 0xf1, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x8f, + 0xf4, 0xaf, 0xf1, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xf4, 0xaf, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xf4, 0xaf, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf4, 0xaf, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf4, 0xaf, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xf4, + + /* U+004F "O" */ + 0x0, 0x0, 0x0, 0x38, 0xce, 0xfe, 0xd9, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xd4, 0x0, 0x0, 0x0, 0x3, 0xef, + 0xff, 0xc9, 0x78, 0xaf, 0xff, 0xf7, 0x0, 0x0, + 0x2, 0xff, 0xfb, 0x20, 0x0, 0x0, 0x8, 0xff, + 0xf6, 0x0, 0x0, 0xdf, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf3, 0x0, 0x6f, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xb0, 0xd, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0x21, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xf7, 0x5f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xb7, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xfd, 0x8f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xe9, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xfe, 0x8f, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xd5, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xfb, 0x2f, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0x70, 0xcf, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf2, + 0x6, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfb, 0x0, 0xd, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0x30, 0x0, 0x2f, 0xff, + 0xb2, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x60, 0x0, + 0x0, 0x3e, 0xff, 0xfc, 0x87, 0x8a, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x1a, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x40, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x8c, 0xef, 0xed, 0x95, 0x0, 0x0, 0x0, + + /* U+0050 "P" */ + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xec, 0x93, 0x0, + 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0xbf, 0xf9, 0x88, 0x88, 0x89, 0xad, 0xff, + 0xf8, 0xb, 0xff, 0x20, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xf2, 0xbf, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0x7b, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xfa, 0xbf, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xab, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xf9, 0xbf, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0x5b, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xe0, 0xbf, 0xf9, 0x88, + 0x88, 0x89, 0xbf, 0xff, 0xf5, 0xb, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xeb, 0x71, 0x0, 0xb, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+0051 "Q" */ + 0x0, 0x0, 0x0, 0x38, 0xce, 0xff, 0xda, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1a, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x40, 0x0, 0x0, 0x0, 0x3, + 0xef, 0xff, 0xc9, 0x78, 0xaf, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xb2, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x70, 0x0, 0x0, 0xcf, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf3, 0x0, 0x5, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xfb, 0x0, 0xd, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0x20, 0x1f, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x70, + 0x5f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xb0, 0x7f, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xd0, 0x8f, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xe0, 0x8f, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xe0, 0x7f, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xc0, 0x5f, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xb0, 0x1f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0x70, 0xc, 0xff, 0x30, + 0x0, 0x0, 0x2, 0x0, 0x0, 0xd, 0xff, 0x20, + 0x5, 0xff, 0xc0, 0x0, 0x0, 0xd, 0xe8, 0x0, + 0x7f, 0xfb, 0x0, 0x0, 0xcf, 0xf9, 0x0, 0x0, + 0x1f, 0xff, 0xe7, 0xff, 0xf3, 0x0, 0x0, 0x2f, + 0xff, 0xb2, 0x0, 0x0, 0x6e, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x3, 0xef, 0xff, 0xc8, 0x78, 0xbf, + 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, 0x2b, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0xff, 0xf9, 0x10, 0x0, + 0x0, 0x0, 0x38, 0xce, 0xff, 0xd9, 0x40, 0x1b, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5d, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x10, + + /* U+0052 "R" */ + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xd9, 0x40, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x9f, 0xf8, 0x66, 0x66, + 0x66, 0x68, 0xcf, 0xff, 0x70, 0x0, 0x9f, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf1, 0x0, + 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xf6, 0x0, 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xf8, 0x0, 0x9f, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xf8, 0x0, 0x9f, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf6, 0x0, + 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf2, 0x0, 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x13, + 0x8f, 0xff, 0x90, 0x0, 0x9f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x50, 0x0, 0x0, + 0x9f, 0xf9, 0x77, 0x79, 0xcf, 0xfe, 0x40, 0x0, + 0x0, 0x0, 0x9f, 0xf4, 0x0, 0x0, 0x4, 0xef, + 0xf6, 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x50, 0x0, 0x0, 0x9f, 0xf4, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf2, 0x0, 0x0, + 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfc, + 0x0, 0x0, 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x70, 0x0, 0x9f, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf2, 0x0, 0x9f, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfb, 0x0, + 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0x50, 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xe1, + + /* U+0053 "S" */ + 0x0, 0x0, 0x28, 0xce, 0xff, 0xda, 0x60, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x40, 0x0, 0x0, 0x9f, 0xff, 0xd9, 0x88, 0xae, + 0xff, 0xf5, 0x0, 0x4, 0xff, 0xe3, 0x0, 0x0, + 0x0, 0x7f, 0xfe, 0x10, 0xa, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x9, 0xff, 0x70, 0xc, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xa0, 0xb, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x87, 0x50, 0x8, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xfe, 0x94, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3e, 0xff, 0xff, 0xfc, 0x84, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x9f, 0xff, 0xff, 0xff, + 0xfa, 0x20, 0x0, 0x0, 0x0, 0x0, 0x49, 0xdf, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x5a, 0xef, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xe0, 0x25, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf4, 0x9f, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf6, + 0x6f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xf5, 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xf1, 0x8, 0xff, 0xf8, 0x10, 0x0, 0x0, + 0x2c, 0xff, 0xa0, 0x0, 0xbf, 0xff, 0xfc, 0xa9, + 0xad, 0xff, 0xfd, 0x10, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb1, 0x0, 0x0, 0x0, 0x17, + 0xbd, 0xff, 0xfd, 0x93, 0x0, 0x0, + + /* U+0054 "T" */ + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x38, 0x88, 0x88, 0x8a, 0xff, 0xc8, + 0x88, 0x88, 0x85, 0x0, 0x0, 0x0, 0x4, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0x90, 0x0, 0x0, 0x0, + + /* U+0055 "U" */ + 0x9f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xf4, 0x9f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf4, 0x9f, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xf4, 0x9f, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf4, 0x9f, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x9f, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x9f, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x9f, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, + 0x9f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xf4, 0x9f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf4, 0x9f, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xf4, 0x9f, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf4, 0x9f, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x8f, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf3, 0x8f, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf2, 0x5f, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf1, + 0x2f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xe0, 0xd, 0xff, 0x40, 0x0, 0x0, 0x0, 0x9, + 0xff, 0x90, 0x7, 0xff, 0xf5, 0x0, 0x0, 0x1, + 0x8f, 0xff, 0x20, 0x0, 0xcf, 0xff, 0xeb, 0x9a, + 0xcf, 0xff, 0xf6, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x39, + 0xce, 0xff, 0xeb, 0x61, 0x0, 0x0, + + /* U+0056 "V" */ + 0xaf, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xf9, 0x4f, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xf3, 0xe, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xd0, 0x8, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0x70, + 0x2, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0x10, 0x0, 0xcf, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xfb, 0x0, 0x0, 0x6f, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xf4, 0x0, 0x0, 0xf, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xe0, 0x0, + 0x0, 0xa, 0xff, 0x20, 0x0, 0x0, 0x3, 0xff, + 0x80, 0x0, 0x0, 0x4, 0xff, 0x80, 0x0, 0x0, + 0x8, 0xff, 0x20, 0x0, 0x0, 0x0, 0xef, 0xe0, + 0x0, 0x0, 0xe, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf3, 0x0, 0x0, 0x4f, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xf9, 0x0, 0x0, 0xaf, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xfe, 0x0, 0x0, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0x40, 0x5, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xa0, 0xb, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf0, 0x1f, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf4, 0x6f, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xf9, 0xbf, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xfe, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf9, + 0x0, 0x0, 0x0, 0x0, + + /* U+0057 "W" */ + 0x8f, 0xf5, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xfc, 0x4f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x4f, 0xf8, 0xf, 0xfc, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x8f, 0xf4, 0xc, 0xff, 0x0, 0x0, 0x0, 0x8, + 0xfe, 0xbf, 0xd0, 0x0, 0x0, 0x0, 0xcf, 0xf0, + 0x8, 0xff, 0x30, 0x0, 0x0, 0xc, 0xfa, 0x6f, + 0xf1, 0x0, 0x0, 0x0, 0xff, 0xb0, 0x4, 0xff, + 0x70, 0x0, 0x0, 0x1f, 0xf6, 0x2f, 0xf6, 0x0, + 0x0, 0x4, 0xff, 0x70, 0x0, 0xff, 0xb0, 0x0, + 0x0, 0x5f, 0xf2, 0xe, 0xfa, 0x0, 0x0, 0x7, + 0xff, 0x20, 0x0, 0xcf, 0xe0, 0x0, 0x0, 0x9f, + 0xd0, 0xa, 0xfe, 0x0, 0x0, 0xb, 0xfe, 0x0, + 0x0, 0x7f, 0xf2, 0x0, 0x0, 0xef, 0x90, 0x5, + 0xff, 0x30, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x3f, + 0xf5, 0x0, 0x2, 0xff, 0x40, 0x1, 0xff, 0x80, + 0x0, 0x3f, 0xf6, 0x0, 0x0, 0xf, 0xf9, 0x0, + 0x7, 0xff, 0x0, 0x0, 0xdf, 0xc0, 0x0, 0x7f, + 0xf1, 0x0, 0x0, 0xb, 0xfd, 0x0, 0xb, 0xfc, + 0x0, 0x0, 0x8f, 0xf0, 0x0, 0xbf, 0xd0, 0x0, + 0x0, 0x7, 0xff, 0x0, 0xf, 0xf7, 0x0, 0x0, + 0x4f, 0xf4, 0x0, 0xef, 0x90, 0x0, 0x0, 0x3, + 0xff, 0x40, 0x4f, 0xf3, 0x0, 0x0, 0xf, 0xf8, + 0x2, 0xff, 0x40, 0x0, 0x0, 0x0, 0xef, 0x70, + 0x8f, 0xe0, 0x0, 0x0, 0xb, 0xfc, 0x6, 0xff, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xb0, 0xcf, 0xa0, + 0x0, 0x0, 0x7, 0xff, 0xa, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xe0, 0xff, 0x60, 0x0, 0x0, + 0x3, 0xff, 0x2d, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xf6, 0xff, 0x20, 0x0, 0x0, 0x0, 0xef, + 0x7f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xe, 0xfd, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xdf, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0x20, 0x0, 0x0, + + /* U+0058 "X" */ + 0x8, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xd0, 0x0, 0xdf, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0x20, 0x0, 0x2f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0xbf, 0xf6, 0x0, 0x0, 0x7, + 0xff, 0xd0, 0x0, 0x0, 0x7, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0xcf, 0xf9, 0x0, 0x0, 0x3f, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x40, 0x0, + 0xdf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xe1, 0xa, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xfa, 0x5f, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xef, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf7, 0x8f, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xc0, 0xd, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x20, 0x3, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf6, 0x0, 0x0, 0x7f, 0xfe, + 0x10, 0x0, 0x0, 0x9, 0xff, 0xb0, 0x0, 0x0, + 0xc, 0xff, 0xa0, 0x0, 0x0, 0x5f, 0xfe, 0x10, + 0x0, 0x0, 0x2, 0xff, 0xf5, 0x0, 0x1, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x10, + 0xc, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xc0, 0x8f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xf7, + + /* U+0059 "Y" */ + 0x9f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xf7, 0xe, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xc0, 0x4, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x20, 0x0, 0xaf, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf6, 0x0, + 0x0, 0x1e, 0xff, 0x60, 0x0, 0x0, 0x6, 0xff, + 0xb0, 0x0, 0x0, 0x5, 0xff, 0xf1, 0x0, 0x0, + 0x1f, 0xff, 0x10, 0x0, 0x0, 0x0, 0xaf, 0xfb, + 0x0, 0x0, 0xbf, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0x50, 0x5, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xe0, 0xe, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf7, 0x8f, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf3, + 0x0, 0x0, 0x0, 0x0, + + /* U+005A "Z" */ + 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf2, 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf2, 0x1, 0x88, 0x88, 0x88, 0x88, 0x88, + 0x8b, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2e, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xfe, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x98, 0x88, 0x88, + 0x88, 0x88, 0x88, 0x84, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf8, 0x7f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + + /* U+005B "[" */ + 0xff, 0xff, 0xfd, 0xff, 0xff, 0xfd, 0xff, 0xb3, + 0x32, 0xff, 0xa0, 0x0, 0xff, 0xa0, 0x0, 0xff, + 0xa0, 0x0, 0xff, 0xa0, 0x0, 0xff, 0xa0, 0x0, + 0xff, 0xa0, 0x0, 0xff, 0xa0, 0x0, 0xff, 0xa0, + 0x0, 0xff, 0xa0, 0x0, 0xff, 0xa0, 0x0, 0xff, + 0xa0, 0x0, 0xff, 0xa0, 0x0, 0xff, 0xa0, 0x0, + 0xff, 0xa0, 0x0, 0xff, 0xa0, 0x0, 0xff, 0xa0, + 0x0, 0xff, 0xa0, 0x0, 0xff, 0xa0, 0x0, 0xff, + 0xa0, 0x0, 0xff, 0xa0, 0x0, 0xff, 0xa0, 0x0, + 0xff, 0xa0, 0x0, 0xff, 0xb3, 0x32, 0xff, 0xff, + 0xfd, 0xff, 0xff, 0xfd, + + /* U+005C "\\" */ + 0xdf, 0x40, 0x0, 0x0, 0x9, 0xf8, 0x0, 0x0, + 0x0, 0x4f, 0xd0, 0x0, 0x0, 0x0, 0xff, 0x10, + 0x0, 0x0, 0xb, 0xf6, 0x0, 0x0, 0x0, 0x7f, + 0xa0, 0x0, 0x0, 0x2, 0xff, 0x0, 0x0, 0x0, + 0xe, 0xf3, 0x0, 0x0, 0x0, 0x9f, 0x80, 0x0, + 0x0, 0x5, 0xfc, 0x0, 0x0, 0x0, 0xf, 0xf1, + 0x0, 0x0, 0x0, 0xcf, 0x50, 0x0, 0x0, 0x7, + 0xfa, 0x0, 0x0, 0x0, 0x2f, 0xe0, 0x0, 0x0, + 0x0, 0xef, 0x30, 0x0, 0x0, 0x9, 0xf7, 0x0, + 0x0, 0x0, 0x5f, 0xc0, 0x0, 0x0, 0x1, 0xff, + 0x10, 0x0, 0x0, 0xc, 0xf5, 0x0, 0x0, 0x0, + 0x7f, 0x90, 0x0, 0x0, 0x3, 0xfe, 0x0, 0x0, + 0x0, 0xe, 0xf2, + + /* U+005D "]" */ + 0x7f, 0xff, 0xff, 0x57, 0xff, 0xff, 0xf5, 0x13, + 0x36, 0xff, 0x50, 0x0, 0x4f, 0xf5, 0x0, 0x4, + 0xff, 0x50, 0x0, 0x4f, 0xf5, 0x0, 0x4, 0xff, + 0x50, 0x0, 0x4f, 0xf5, 0x0, 0x4, 0xff, 0x50, + 0x0, 0x4f, 0xf5, 0x0, 0x4, 0xff, 0x50, 0x0, + 0x4f, 0xf5, 0x0, 0x4, 0xff, 0x50, 0x0, 0x4f, + 0xf5, 0x0, 0x4, 0xff, 0x50, 0x0, 0x4f, 0xf5, + 0x0, 0x4, 0xff, 0x50, 0x0, 0x4f, 0xf5, 0x0, + 0x4, 0xff, 0x50, 0x0, 0x4f, 0xf5, 0x0, 0x4, + 0xff, 0x50, 0x0, 0x4f, 0xf5, 0x0, 0x4, 0xff, + 0x50, 0x0, 0x4f, 0xf5, 0x0, 0x4, 0xff, 0x51, + 0x33, 0x7f, 0xf5, 0x7f, 0xff, 0xff, 0x57, 0xff, + 0xff, 0xf5, + + /* U+005E "^" */ + 0x0, 0x0, 0x4, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xdc, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xef, 0x76, + 0xff, 0x10, 0x0, 0x0, 0x6, 0xff, 0x10, 0xff, + 0x70, 0x0, 0x0, 0xd, 0xfa, 0x0, 0x9f, 0xe0, + 0x0, 0x0, 0x4f, 0xf4, 0x0, 0x2f, 0xf5, 0x0, + 0x0, 0xbf, 0xd0, 0x0, 0xc, 0xfc, 0x0, 0x2, + 0xff, 0x70, 0x0, 0x6, 0xff, 0x30, 0x8, 0xff, + 0x10, 0x0, 0x0, 0xef, 0xa0, 0xf, 0xfb, 0x0, + 0x0, 0x0, 0x9f, 0xf1, + + /* U+005F "_" */ + 0x2e, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, + 0xec, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, + + /* U+0060 "`" */ + 0x12, 0x21, 0x0, 0x3f, 0xff, 0x20, 0x5, 0xff, + 0x90, 0x0, 0x8f, 0xf1, 0x0, 0xb, 0xf9, + + /* U+0061 "a" */ + 0x0, 0x3, 0x9d, 0xff, 0xfd, 0x93, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x8, + 0xff, 0xd6, 0x43, 0x49, 0xff, 0xf3, 0x1, 0xff, + 0xd0, 0x0, 0x0, 0x8, 0xff, 0x70, 0x3d, 0xf6, + 0x0, 0x0, 0x0, 0x2f, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x24, 0x7a, 0xef, 0xfa, 0x0, 0x2, 0x8d, 0xff, + 0xff, 0xff, 0xff, 0xa0, 0x7, 0xff, 0xff, 0xfc, + 0xa6, 0x2f, 0xfa, 0x5, 0xff, 0xe7, 0x20, 0x0, + 0x1, 0xff, 0xa0, 0xbf, 0xf4, 0x0, 0x0, 0x0, + 0x3f, 0xfa, 0xd, 0xff, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xa0, 0xcf, 0xf3, 0x0, 0x0, 0x4, 0xff, + 0xfa, 0x6, 0xff, 0xe6, 0x21, 0x49, 0xff, 0xff, + 0xb0, 0xb, 0xff, 0xff, 0xff, 0xff, 0x8c, 0xfe, + 0x0, 0x5, 0xbe, 0xfe, 0xc9, 0x20, 0x7f, 0xf3, + + /* U+0062 "b" */ + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xa0, 0x6c, 0xff, 0xc7, 0x0, + 0x0, 0xff, 0xbb, 0xff, 0xff, 0xff, 0xd2, 0x0, + 0xff, 0xff, 0xd6, 0x34, 0xaf, 0xfe, 0x0, 0xff, + 0xfc, 0x0, 0x0, 0x7, 0xff, 0x90, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0xdf, 0xf0, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x8f, 0xf4, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x4f, 0xf6, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x3f, 0xf7, 0xff, 0x70, 0x0, 0x0, 0x0, 0x3f, + 0xf7, 0xff, 0x80, 0x0, 0x0, 0x0, 0x5f, 0xf6, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x8f, 0xf3, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0xef, 0xe0, 0xff, 0xfb, + 0x0, 0x0, 0x9, 0xff, 0x70, 0xff, 0xff, 0xd5, + 0x35, 0xbf, 0xfc, 0x0, 0xff, 0x8c, 0xff, 0xff, + 0xff, 0xc1, 0x0, 0xff, 0x70, 0x7d, 0xfe, 0xb5, + 0x0, 0x0, + + /* U+0063 "c" */ + 0x0, 0x1, 0x8c, 0xef, 0xea, 0x40, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x3, 0xff, + 0xf9, 0x43, 0x5d, 0xff, 0x80, 0xd, 0xff, 0x40, + 0x0, 0x0, 0xdf, 0xf1, 0x4f, 0xf8, 0x0, 0x0, + 0x0, 0x5f, 0xf5, 0x8f, 0xf2, 0x0, 0x0, 0x0, + 0x2, 0x0, 0xbf, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf2, + 0x0, 0x0, 0x0, 0xe, 0xc7, 0x4f, 0xf8, 0x0, + 0x0, 0x0, 0x4f, 0xf7, 0xd, 0xff, 0x20, 0x0, + 0x0, 0xdf, 0xf1, 0x3, 0xff, 0xf8, 0x43, 0x6d, + 0xff, 0x70, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x1, 0x8c, 0xef, 0xea, 0x30, 0x0, + + /* U+0064 "d" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xf9, 0x0, 0x2, 0x9e, 0xfe, 0xa3, 0xf, + 0xf9, 0x0, 0x6f, 0xff, 0xff, 0xff, 0x6f, 0xf9, + 0x5, 0xff, 0xe7, 0x34, 0x8f, 0xff, 0xf9, 0xe, + 0xff, 0x20, 0x0, 0x4, 0xff, 0xf9, 0x6f, 0xf7, + 0x0, 0x0, 0x0, 0x9f, 0xf9, 0xaf, 0xf1, 0x0, + 0x0, 0x0, 0x3f, 0xf9, 0xdf, 0xe0, 0x0, 0x0, + 0x0, 0xf, 0xf9, 0xef, 0xd0, 0x0, 0x0, 0x0, + 0xd, 0xf9, 0xef, 0xd0, 0x0, 0x0, 0x0, 0xd, + 0xf9, 0xcf, 0xe0, 0x0, 0x0, 0x0, 0xe, 0xf9, + 0x9f, 0xf2, 0x0, 0x0, 0x0, 0x1f, 0xf9, 0x5f, + 0xf8, 0x0, 0x0, 0x0, 0x7f, 0xf9, 0xd, 0xff, + 0x30, 0x0, 0x3, 0xff, 0xf9, 0x3, 0xff, 0xf8, + 0x33, 0x8f, 0xff, 0xf9, 0x0, 0x5f, 0xff, 0xff, + 0xff, 0x6e, 0xf9, 0x0, 0x1, 0x9d, 0xfe, 0xb4, + 0xe, 0xf9, + + /* U+0065 "e" */ + 0x0, 0x0, 0x7c, 0xef, 0xeb, 0x50, 0x0, 0x0, + 0x3, 0xef, 0xff, 0xff, 0xff, 0xc1, 0x0, 0x2, + 0xff, 0xf8, 0x43, 0x5a, 0xff, 0xd0, 0x0, 0xcf, + 0xf3, 0x0, 0x0, 0x4, 0xff, 0x90, 0x3f, 0xf7, + 0x0, 0x0, 0x0, 0xa, 0xff, 0x8, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x5f, 0xf4, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x6c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf7, 0xdf, 0xe3, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x1b, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x0, 0x0, 0x0, + 0x3, 0x75, 0x14, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0xcf, 0xf2, 0xd, 0xff, 0x70, 0x0, 0x0, 0x7f, + 0xfb, 0x0, 0x3f, 0xff, 0xb5, 0x35, 0xbf, 0xff, + 0x20, 0x0, 0x4e, 0xff, 0xff, 0xff, 0xfe, 0x30, + 0x0, 0x0, 0x7, 0xce, 0xff, 0xc7, 0x10, 0x0, + + /* U+0066 "f" */ + 0x0, 0x0, 0x8d, 0xff, 0xd3, 0x0, 0xb, 0xff, + 0xff, 0xf1, 0x0, 0x3f, 0xfe, 0x97, 0x80, 0x0, + 0x6f, 0xf5, 0x0, 0x0, 0x0, 0x6f, 0xf3, 0x0, + 0x0, 0x0, 0x7f, 0xf3, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xff, 0x30, 0xcf, 0xff, 0xff, 0xff, 0x30, + 0x1, 0x7f, 0xf3, 0x11, 0x0, 0x0, 0x7f, 0xf3, + 0x0, 0x0, 0x0, 0x7f, 0xf3, 0x0, 0x0, 0x0, + 0x7f, 0xf3, 0x0, 0x0, 0x0, 0x7f, 0xf3, 0x0, + 0x0, 0x0, 0x7f, 0xf3, 0x0, 0x0, 0x0, 0x7f, + 0xf3, 0x0, 0x0, 0x0, 0x7f, 0xf3, 0x0, 0x0, + 0x0, 0x7f, 0xf3, 0x0, 0x0, 0x0, 0x7f, 0xf3, + 0x0, 0x0, 0x0, 0x7f, 0xf3, 0x0, 0x0, 0x0, + 0x7f, 0xf3, 0x0, 0x0, 0x0, 0x7f, 0xf3, 0x0, + 0x0, 0x0, 0x7f, 0xf3, 0x0, 0x0, + + /* U+0067 "g" */ + 0x0, 0x2, 0x9d, 0xfe, 0xb4, 0xb, 0xfb, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0x9b, 0xfb, 0x5, 0xff, + 0xf7, 0x33, 0x8f, 0xff, 0xfb, 0xe, 0xff, 0x20, + 0x0, 0x3, 0xff, 0xfb, 0x5f, 0xf7, 0x0, 0x0, + 0x0, 0x7f, 0xfb, 0xaf, 0xf1, 0x0, 0x0, 0x0, + 0x1f, 0xfb, 0xdf, 0xd0, 0x0, 0x0, 0x0, 0xd, + 0xfb, 0xef, 0xc0, 0x0, 0x0, 0x0, 0xb, 0xfb, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0xc, 0xfb, 0xdf, + 0xd0, 0x0, 0x0, 0x0, 0xd, 0xfb, 0xaf, 0xf0, + 0x0, 0x0, 0x0, 0xf, 0xfb, 0x5f, 0xf6, 0x0, + 0x0, 0x0, 0x6f, 0xfb, 0xe, 0xfe, 0x20, 0x0, + 0x2, 0xef, 0xfb, 0x4, 0xff, 0xf8, 0x44, 0x8f, + 0xff, 0xfb, 0x0, 0x6f, 0xff, 0xff, 0xff, 0x7f, + 0xfb, 0x0, 0x2, 0x9d, 0xfe, 0xb3, 0xf, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xf8, 0x5a, + 0x81, 0x0, 0x0, 0x0, 0x4f, 0xf5, 0x4f, 0xf7, + 0x0, 0x0, 0x0, 0xcf, 0xf1, 0xd, 0xff, 0x94, + 0x34, 0x7d, 0xff, 0x70, 0x3, 0xef, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x17, 0xce, 0xfe, 0xc8, + 0x20, 0x0, + + /* U+0068 "h" */ + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xa0, 0x4b, 0xef, 0xea, 0x30, 0xf, 0xfa, 0xaf, + 0xff, 0xff, 0xff, 0x60, 0xff, 0xff, 0xe8, 0x56, + 0xbf, 0xff, 0x1f, 0xff, 0xc1, 0x0, 0x0, 0xaf, + 0xf6, 0xff, 0xf2, 0x0, 0x0, 0x2, 0xff, 0x9f, + 0xfd, 0x0, 0x0, 0x0, 0xf, 0xfa, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0xff, 0xaf, 0xfa, 0x0, 0x0, + 0x0, 0xf, 0xfb, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0xff, 0xbf, 0xfa, 0x0, 0x0, 0x0, 0xf, 0xfb, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0xff, 0xbf, 0xfa, + 0x0, 0x0, 0x0, 0xf, 0xfb, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0xff, 0xbf, 0xfa, 0x0, 0x0, 0x0, + 0xf, 0xfb, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xff, + 0xbf, 0xfa, 0x0, 0x0, 0x0, 0xf, 0xfb, + + /* U+0069 "i" */ + 0xff, 0xaf, 0xfa, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xff, + 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, + 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, + 0xfa, + + /* U+006A "j" */ + 0x0, 0x0, 0xff, 0xa0, 0x0, 0xf, 0xfa, 0x0, + 0x0, 0xff, 0xa0, 0x0, 0x1, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xa0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0xff, 0xa0, + 0x0, 0xf, 0xfa, 0x0, 0x0, 0xff, 0xa0, 0x0, + 0xf, 0xfa, 0x0, 0x0, 0xff, 0xa0, 0x0, 0xf, + 0xfa, 0x0, 0x0, 0xff, 0xa0, 0x0, 0xf, 0xfa, + 0x0, 0x0, 0xff, 0xa0, 0x0, 0xf, 0xfa, 0x0, + 0x0, 0xff, 0xa0, 0x0, 0xf, 0xfa, 0x0, 0x0, + 0xff, 0xa0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0xff, + 0xa0, 0x0, 0xf, 0xf9, 0x0, 0x2, 0xff, 0x80, + 0x65, 0xcf, 0xf4, 0xf, 0xff, 0xfd, 0x2, 0xef, + 0xfa, 0x20, + + /* U+006B "k" */ + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xa0, 0x0, 0x0, 0x9f, 0xfb, 0xf, 0xfa, 0x0, + 0x0, 0x9f, 0xfb, 0x0, 0xff, 0xa0, 0x0, 0x8f, + 0xfb, 0x0, 0xf, 0xfa, 0x0, 0x7f, 0xfb, 0x0, + 0x0, 0xff, 0xa0, 0x7f, 0xfb, 0x0, 0x0, 0xf, + 0xfa, 0x6f, 0xfb, 0x0, 0x0, 0x0, 0xff, 0xef, + 0xff, 0xb0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0xff, 0xfb, 0x2f, 0xfe, 0x10, + 0x0, 0xf, 0xfc, 0x0, 0x7f, 0xfa, 0x0, 0x0, + 0xff, 0xa0, 0x0, 0xdf, 0xf4, 0x0, 0xf, 0xfa, + 0x0, 0x3, 0xff, 0xe0, 0x0, 0xff, 0xa0, 0x0, + 0x9, 0xff, 0x90, 0xf, 0xfa, 0x0, 0x0, 0xe, + 0xff, 0x40, 0xff, 0xa0, 0x0, 0x0, 0x5f, 0xfd, + 0xf, 0xfa, 0x0, 0x0, 0x0, 0xbf, 0xf9, + + /* U+006C "l" */ + 0xf, 0xf9, 0xf, 0xf9, 0xf, 0xf9, 0xf, 0xf9, + 0xf, 0xf9, 0xf, 0xf9, 0xf, 0xf9, 0xf, 0xf9, + 0xf, 0xf9, 0xf, 0xf9, 0xf, 0xf9, 0xf, 0xf9, + 0xf, 0xf9, 0xf, 0xf9, 0xf, 0xf9, 0xf, 0xf9, + 0xf, 0xf9, 0xf, 0xf9, 0xf, 0xf9, 0xf, 0xf9, + 0xf, 0xf9, 0xf, 0xf9, + + /* U+006D "m" */ + 0xf, 0xf5, 0x6, 0xce, 0xfd, 0x70, 0x0, 0x4b, + 0xef, 0xd9, 0x10, 0x0, 0xff, 0x5b, 0xff, 0xff, + 0xff, 0xb0, 0x7f, 0xff, 0xff, 0xfe, 0x10, 0xf, + 0xfe, 0xfd, 0x65, 0x8f, 0xff, 0xaf, 0xe7, 0x57, + 0xef, 0xf8, 0x0, 0xff, 0xfa, 0x0, 0x0, 0x5f, + 0xff, 0xd1, 0x0, 0x1, 0xff, 0xd0, 0xf, 0xff, + 0x10, 0x0, 0x0, 0xff, 0xf4, 0x0, 0x0, 0xb, + 0xff, 0x0, 0xff, 0xc0, 0x0, 0x0, 0xd, 0xff, + 0x0, 0x0, 0x0, 0x9f, 0xf0, 0xf, 0xfa, 0x0, + 0x0, 0x0, 0xcf, 0xd0, 0x0, 0x0, 0x9, 0xff, + 0x0, 0xff, 0x90, 0x0, 0x0, 0xc, 0xfd, 0x0, + 0x0, 0x0, 0x9f, 0xf0, 0xf, 0xf9, 0x0, 0x0, + 0x0, 0xcf, 0xd0, 0x0, 0x0, 0x9, 0xff, 0x0, + 0xff, 0x90, 0x0, 0x0, 0xc, 0xfd, 0x0, 0x0, + 0x0, 0x9f, 0xf0, 0xf, 0xf9, 0x0, 0x0, 0x0, + 0xcf, 0xd0, 0x0, 0x0, 0x9, 0xff, 0x0, 0xff, + 0x90, 0x0, 0x0, 0xc, 0xfd, 0x0, 0x0, 0x0, + 0x9f, 0xf0, 0xf, 0xf9, 0x0, 0x0, 0x0, 0xcf, + 0xd0, 0x0, 0x0, 0x9, 0xff, 0x0, 0xff, 0x90, + 0x0, 0x0, 0xc, 0xfd, 0x0, 0x0, 0x0, 0x9f, + 0xf0, 0xf, 0xf9, 0x0, 0x0, 0x0, 0xcf, 0xd0, + 0x0, 0x0, 0x9, 0xff, 0x0, 0xff, 0x90, 0x0, + 0x0, 0xc, 0xfd, 0x0, 0x0, 0x0, 0x9f, 0xf0, + + /* U+006E "n" */ + 0xff, 0x60, 0x4b, 0xef, 0xd9, 0x20, 0xf, 0xf6, + 0x9f, 0xff, 0xff, 0xff, 0x50, 0xff, 0xdf, 0xe7, + 0x56, 0xbf, 0xff, 0x1f, 0xff, 0xc0, 0x0, 0x0, + 0xaf, 0xf6, 0xff, 0xf2, 0x0, 0x0, 0x3, 0xff, + 0x9f, 0xfd, 0x0, 0x0, 0x0, 0xf, 0xfa, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0xff, 0xaf, 0xfa, 0x0, + 0x0, 0x0, 0xf, 0xfa, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0xff, 0xaf, 0xfa, 0x0, 0x0, 0x0, 0xf, + 0xfa, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xff, 0xaf, + 0xfa, 0x0, 0x0, 0x0, 0xf, 0xfa, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0xff, 0xaf, 0xfa, 0x0, 0x0, + 0x0, 0xf, 0xfa, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0xff, 0xaf, 0xfa, 0x0, 0x0, 0x0, 0xf, 0xfa, + + /* U+006F "o" */ + 0x0, 0x0, 0x7c, 0xef, 0xeb, 0x50, 0x0, 0x0, + 0x4, 0xef, 0xff, 0xff, 0xff, 0xc1, 0x0, 0x4, + 0xff, 0xf9, 0x43, 0x5c, 0xff, 0xd0, 0x0, 0xef, + 0xf4, 0x0, 0x0, 0x9, 0xff, 0x90, 0x6f, 0xf8, + 0x0, 0x0, 0x0, 0xd, 0xff, 0x1a, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x6f, 0xf5, 0xdf, 0xe0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0x8e, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xf9, 0xef, 0xc0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0x9d, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xf8, 0xaf, 0xf1, 0x0, 0x0, 0x0, + 0x6, 0xff, 0x56, 0xff, 0x80, 0x0, 0x0, 0x0, + 0xdf, 0xf1, 0xe, 0xff, 0x40, 0x0, 0x0, 0x8f, + 0xf9, 0x0, 0x4f, 0xff, 0x94, 0x35, 0xcf, 0xfe, + 0x10, 0x0, 0x4e, 0xff, 0xff, 0xff, 0xfc, 0x20, + 0x0, 0x0, 0x17, 0xce, 0xfe, 0xb5, 0x0, 0x0, + + /* U+0070 "p" */ + 0xff, 0x70, 0x6c, 0xff, 0xc7, 0x0, 0x0, 0xff, + 0x7c, 0xff, 0xff, 0xff, 0xe2, 0x0, 0xff, 0xff, + 0xd4, 0x13, 0x9f, 0xfe, 0x10, 0xff, 0xfc, 0x0, + 0x0, 0x7, 0xff, 0x90, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0xcf, 0xf0, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x7f, 0xf4, 0xff, 0x80, 0x0, 0x0, 0x0, 0x4f, + 0xf7, 0xff, 0x70, 0x0, 0x0, 0x0, 0x2f, 0xf8, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x3f, 0xf7, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x4f, 0xf6, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x7f, 0xf3, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0xdf, 0xe0, 0xff, 0xfb, 0x0, 0x0, + 0x9, 0xff, 0x70, 0xff, 0xff, 0xc5, 0x35, 0xbf, + 0xfc, 0x0, 0xff, 0xbc, 0xff, 0xff, 0xff, 0xc1, + 0x0, 0xff, 0xa0, 0x7d, 0xfe, 0xc6, 0x0, 0x0, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0071 "q" */ + 0x0, 0x2, 0x9d, 0xfe, 0xa3, 0xc, 0xf9, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0x6c, 0xf9, 0x5, 0xff, + 0xe6, 0x22, 0x7f, 0xfe, 0xf9, 0xe, 0xfe, 0x20, + 0x0, 0x3, 0xff, 0xf9, 0x5f, 0xf7, 0x0, 0x0, + 0x0, 0x9f, 0xf9, 0xaf, 0xf1, 0x0, 0x0, 0x0, + 0x2f, 0xf9, 0xcf, 0xe0, 0x0, 0x0, 0x0, 0xe, + 0xf9, 0xdf, 0xd0, 0x0, 0x0, 0x0, 0xd, 0xf9, + 0xdf, 0xd0, 0x0, 0x0, 0x0, 0xc, 0xf9, 0xcf, + 0xf0, 0x0, 0x0, 0x0, 0xe, 0xf9, 0x8f, 0xf2, + 0x0, 0x0, 0x0, 0x1f, 0xf9, 0x3f, 0xf9, 0x0, + 0x0, 0x0, 0x7f, 0xf9, 0xc, 0xff, 0x40, 0x0, + 0x2, 0xff, 0xf9, 0x2, 0xff, 0xf8, 0x43, 0x7f, + 0xff, 0xf9, 0x0, 0x4e, 0xff, 0xff, 0xff, 0x8f, + 0xf9, 0x0, 0x1, 0x8d, 0xfe, 0xb3, 0xf, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xf9, + + /* U+0072 "r" */ + 0xf, 0xf5, 0x1a, 0xfe, 0xb2, 0xf, 0xf5, 0xdf, + 0xff, 0xf1, 0xf, 0xfd, 0xfe, 0xce, 0xc0, 0xf, + 0xff, 0xb0, 0x0, 0x10, 0xf, 0xff, 0x10, 0x0, + 0x0, 0xf, 0xfc, 0x0, 0x0, 0x0, 0xf, 0xfa, + 0x0, 0x0, 0x0, 0xf, 0xf9, 0x0, 0x0, 0x0, + 0xf, 0xf9, 0x0, 0x0, 0x0, 0xf, 0xf9, 0x0, + 0x0, 0x0, 0xf, 0xf9, 0x0, 0x0, 0x0, 0xf, + 0xf9, 0x0, 0x0, 0x0, 0xf, 0xf9, 0x0, 0x0, + 0x0, 0xf, 0xf9, 0x0, 0x0, 0x0, 0xf, 0xf9, + 0x0, 0x0, 0x0, 0xf, 0xf9, 0x0, 0x0, 0x0, + + /* U+0073 "s" */ + 0x0, 0x2, 0x9d, 0xff, 0xda, 0x50, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xfd, 0x10, 0x2, 0xff, + 0xe7, 0x33, 0x5c, 0xff, 0xa0, 0x8, 0xff, 0x10, + 0x0, 0x0, 0xcf, 0xf1, 0x9, 0xff, 0x0, 0x0, + 0x0, 0x48, 0x61, 0x7, 0xff, 0xb3, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xe9, 0x51, 0x0, + 0x0, 0x0, 0x2c, 0xff, 0xff, 0xff, 0xb5, 0x0, + 0x0, 0x0, 0x38, 0xdf, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x1, 0x5a, 0xff, 0xf7, 0x0, 0x22, + 0x0, 0x0, 0x0, 0x3f, 0xfc, 0xf, 0xfc, 0x0, + 0x0, 0x0, 0xe, 0xfc, 0xa, 0xff, 0x50, 0x0, + 0x0, 0x4f, 0xf9, 0x2, 0xff, 0xf9, 0x53, 0x48, + 0xff, 0xf2, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x1, 0x8c, 0xff, 0xfc, 0x81, 0x0, + + /* U+0074 "t" */ + 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x8f, 0x0, + 0x0, 0x0, 0x9f, 0xf0, 0x0, 0x0, 0x9, 0xff, + 0x0, 0x0, 0x0, 0x9f, 0xf0, 0x0, 0x0, 0x9, + 0xff, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xfb, 0x8, + 0xff, 0xff, 0xff, 0xb0, 0x1, 0x9f, 0xf1, 0x10, + 0x0, 0x9, 0xff, 0x0, 0x0, 0x0, 0x9f, 0xf0, + 0x0, 0x0, 0x9, 0xff, 0x0, 0x0, 0x0, 0x9f, + 0xf0, 0x0, 0x0, 0x9, 0xff, 0x0, 0x0, 0x0, + 0x9f, 0xf0, 0x0, 0x0, 0x9, 0xff, 0x0, 0x0, + 0x0, 0x9f, 0xf0, 0x0, 0x0, 0x9, 0xff, 0x0, + 0x0, 0x0, 0x8f, 0xf2, 0x0, 0x0, 0x7, 0xff, + 0xc7, 0x60, 0x0, 0x2f, 0xff, 0xfd, 0x0, 0x0, + 0x4c, 0xff, 0xd0, + + /* U+0075 "u" */ + 0xf, 0xf9, 0x0, 0x0, 0x0, 0xf, 0xf9, 0xf, + 0xf9, 0x0, 0x0, 0x0, 0xf, 0xf9, 0xf, 0xf9, + 0x0, 0x0, 0x0, 0xf, 0xf9, 0xf, 0xf9, 0x0, + 0x0, 0x0, 0xf, 0xf9, 0xf, 0xf9, 0x0, 0x0, + 0x0, 0xf, 0xf9, 0xf, 0xf9, 0x0, 0x0, 0x0, + 0xf, 0xf9, 0xf, 0xf9, 0x0, 0x0, 0x0, 0xf, + 0xf9, 0xf, 0xf9, 0x0, 0x0, 0x0, 0xf, 0xf9, + 0xf, 0xf9, 0x0, 0x0, 0x0, 0xf, 0xf9, 0xf, + 0xf9, 0x0, 0x0, 0x0, 0x1f, 0xf9, 0xf, 0xfa, + 0x0, 0x0, 0x0, 0x4f, 0xf9, 0xe, 0xfc, 0x0, + 0x0, 0x0, 0x9f, 0xf9, 0xb, 0xff, 0x40, 0x0, + 0x3, 0xff, 0xf9, 0x5, 0xff, 0xf9, 0x55, 0x9f, + 0xee, 0xf9, 0x0, 0x9f, 0xff, 0xff, 0xfe, 0x3c, + 0xf9, 0x0, 0x5, 0xbe, 0xfd, 0x81, 0xc, 0xf9, + + /* U+0076 "v" */ + 0x7f, 0xf5, 0x0, 0x0, 0x0, 0x3, 0xff, 0x71, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x9f, 0xf1, 0xb, + 0xff, 0x10, 0x0, 0x0, 0xe, 0xfb, 0x0, 0x5f, + 0xf6, 0x0, 0x0, 0x4, 0xff, 0x50, 0x0, 0xef, + 0xb0, 0x0, 0x0, 0xaf, 0xf0, 0x0, 0x9, 0xff, + 0x10, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x3f, 0xf6, + 0x0, 0x5, 0xff, 0x40, 0x0, 0x0, 0xdf, 0xc0, + 0x0, 0xbf, 0xe0, 0x0, 0x0, 0x7, 0xff, 0x20, + 0x1f, 0xf8, 0x0, 0x0, 0x0, 0x1f, 0xf7, 0x6, + 0xff, 0x20, 0x0, 0x0, 0x0, 0xbf, 0xc0, 0xcf, + 0xc0, 0x0, 0x0, 0x0, 0x5, 0xff, 0x3f, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xfc, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xfe, 0x0, 0x0, 0x0, + + /* U+0077 "w" */ + 0xbf, 0xf0, 0x0, 0x0, 0x9, 0xff, 0x60, 0x0, + 0x0, 0x3f, 0xf5, 0x6f, 0xf4, 0x0, 0x0, 0xd, + 0xff, 0xa0, 0x0, 0x0, 0x8f, 0xf0, 0x1f, 0xf8, + 0x0, 0x0, 0x1f, 0xff, 0xe0, 0x0, 0x0, 0xcf, + 0xb0, 0xd, 0xfc, 0x0, 0x0, 0x6f, 0xff, 0xf2, + 0x0, 0x1, 0xff, 0x60, 0x8, 0xff, 0x10, 0x0, + 0xaf, 0xaf, 0xf6, 0x0, 0x5, 0xff, 0x10, 0x3, + 0xff, 0x50, 0x0, 0xef, 0x5c, 0xfa, 0x0, 0xa, + 0xfd, 0x0, 0x0, 0xef, 0x90, 0x2, 0xff, 0x19, + 0xfe, 0x0, 0xe, 0xf8, 0x0, 0x0, 0xaf, 0xe0, + 0x6, 0xfd, 0x5, 0xff, 0x20, 0x3f, 0xf3, 0x0, + 0x0, 0x5f, 0xf2, 0xb, 0xf9, 0x1, 0xff, 0x60, + 0x8f, 0xe0, 0x0, 0x0, 0xf, 0xf6, 0xf, 0xf5, + 0x0, 0xcf, 0xa0, 0xcf, 0x90, 0x0, 0x0, 0xb, + 0xfa, 0x3f, 0xf1, 0x0, 0x8f, 0xe1, 0xff, 0x40, + 0x0, 0x0, 0x7, 0xfe, 0x7f, 0xc0, 0x0, 0x4f, + 0xf8, 0xff, 0x0, 0x0, 0x0, 0x2, 0xff, 0xef, + 0x80, 0x0, 0xf, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x40, 0x0, 0xc, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x0, 0x0, + 0x8, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xfc, 0x0, 0x0, 0x3, 0xff, 0xc0, 0x0, 0x0, + + /* U+0078 "x" */ + 0x1e, 0xff, 0x40, 0x0, 0x0, 0x2f, 0xfe, 0x10, + 0x5f, 0xfd, 0x0, 0x0, 0xc, 0xff, 0x40, 0x0, + 0xaf, 0xf8, 0x0, 0x8, 0xff, 0x90, 0x0, 0x1, + 0xef, 0xf3, 0x3, 0xff, 0xd0, 0x0, 0x0, 0x4, + 0xff, 0xc0, 0xdf, 0xf3, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xdf, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x1, 0xef, 0xe2, 0xef, + 0xe1, 0x0, 0x0, 0x0, 0xbf, 0xf5, 0x5, 0xff, + 0xb0, 0x0, 0x0, 0x6f, 0xfa, 0x0, 0xb, 0xff, + 0x60, 0x0, 0x1f, 0xfe, 0x10, 0x0, 0x1f, 0xff, + 0x20, 0xb, 0xff, 0x60, 0x0, 0x0, 0x6f, 0xfb, + 0x7, 0xff, 0xb0, 0x0, 0x0, 0x0, 0xcf, 0xf7, + + /* U+0079 "y" */ + 0x5f, 0xf8, 0x0, 0x0, 0x0, 0x1, 0xff, 0x80, + 0xef, 0xd0, 0x0, 0x0, 0x0, 0x7f, 0xf2, 0x9, + 0xff, 0x30, 0x0, 0x0, 0xd, 0xfc, 0x0, 0x3f, + 0xf9, 0x0, 0x0, 0x2, 0xff, 0x60, 0x0, 0xdf, + 0xe0, 0x0, 0x0, 0x8f, 0xf1, 0x0, 0x7, 0xff, + 0x40, 0x0, 0xe, 0xfa, 0x0, 0x0, 0x1f, 0xfa, + 0x0, 0x4, 0xff, 0x50, 0x0, 0x0, 0xbf, 0xf0, + 0x0, 0xaf, 0xe0, 0x0, 0x0, 0x5, 0xff, 0x50, + 0xf, 0xf9, 0x0, 0x0, 0x0, 0xe, 0xfb, 0x5, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x8f, 0xf0, 0xaf, + 0xd0, 0x0, 0x0, 0x0, 0x2, 0xff, 0x5e, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xfd, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x4a, + 0xae, 0xff, 0x30, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x2d, 0xfe, + 0x80, 0x0, 0x0, 0x0, 0x0, + + /* U+007A "z" */ + 0xd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x0, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x1, + 0x11, 0x11, 0x11, 0x12, 0xdf, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x2e, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xf5, 0x34, 0x44, 0x44, 0x44, + 0x41, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x56, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + + /* U+007B "{" */ + 0x0, 0x0, 0x4, 0xbe, 0xf5, 0x0, 0x0, 0x4f, + 0xff, 0xf5, 0x0, 0x0, 0xbf, 0xf8, 0x51, 0x0, + 0x0, 0xff, 0x80, 0x0, 0x0, 0x0, 0xff, 0x60, + 0x0, 0x0, 0x1, 0xff, 0x50, 0x0, 0x0, 0x1, + 0xff, 0x50, 0x0, 0x0, 0x2, 0xff, 0x50, 0x0, + 0x0, 0x2, 0xff, 0x40, 0x0, 0x0, 0x4, 0xff, + 0x30, 0x0, 0x0, 0x7, 0xff, 0x10, 0x0, 0x0, + 0xd, 0xfb, 0x0, 0x0, 0x18, 0xdf, 0xe2, 0x0, + 0x0, 0x2f, 0xfb, 0x10, 0x0, 0x0, 0x2f, 0xff, + 0x70, 0x0, 0x0, 0x1, 0x7f, 0xf5, 0x0, 0x0, + 0x0, 0xa, 0xfd, 0x0, 0x0, 0x0, 0x5, 0xff, + 0x20, 0x0, 0x0, 0x3, 0xff, 0x40, 0x0, 0x0, + 0x2, 0xff, 0x50, 0x0, 0x0, 0x2, 0xff, 0x50, + 0x0, 0x0, 0x1, 0xff, 0x50, 0x0, 0x0, 0x1, + 0xff, 0x50, 0x0, 0x0, 0x0, 0xff, 0x60, 0x0, + 0x0, 0x0, 0xff, 0x80, 0x0, 0x0, 0x0, 0xbf, + 0xf8, 0x51, 0x0, 0x0, 0x3f, 0xff, 0xf5, 0x0, + 0x0, 0x4, 0xcf, 0xf5, + + /* U+007C "|" */ + 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, + 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, + 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, + 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, + 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, + 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, + 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, + + /* U+007D "}" */ + 0x5f, 0xfc, 0x40, 0x0, 0x0, 0x5f, 0xff, 0xf3, + 0x0, 0x0, 0x15, 0x8f, 0xfc, 0x0, 0x0, 0x0, + 0x8, 0xff, 0x0, 0x0, 0x0, 0x6, 0xff, 0x0, + 0x0, 0x0, 0x5, 0xff, 0x10, 0x0, 0x0, 0x5, + 0xff, 0x20, 0x0, 0x0, 0x5, 0xff, 0x20, 0x0, + 0x0, 0x4, 0xff, 0x20, 0x0, 0x0, 0x3, 0xff, + 0x40, 0x0, 0x0, 0x0, 0xff, 0x70, 0x0, 0x0, + 0x0, 0xbf, 0xd0, 0x0, 0x0, 0x0, 0x2e, 0xfd, + 0x81, 0x0, 0x0, 0x1, 0xcf, 0xf2, 0x0, 0x0, + 0x7, 0xff, 0xf2, 0x0, 0x0, 0x5f, 0xf7, 0x10, + 0x0, 0x0, 0xdf, 0xa0, 0x0, 0x0, 0x2, 0xff, + 0x60, 0x0, 0x0, 0x4, 0xff, 0x30, 0x0, 0x0, + 0x4, 0xff, 0x20, 0x0, 0x0, 0x5, 0xff, 0x20, + 0x0, 0x0, 0x5, 0xff, 0x20, 0x0, 0x0, 0x5, + 0xff, 0x10, 0x0, 0x0, 0x6, 0xff, 0x0, 0x0, + 0x0, 0x8, 0xff, 0x0, 0x0, 0x15, 0x8f, 0xfb, + 0x0, 0x0, 0x5f, 0xff, 0xf4, 0x0, 0x0, 0x5f, + 0xeb, 0x40, 0x0, 0x0, + + /* U+007E "~" */ + 0x1, 0x7b, 0xca, 0x61, 0x0, 0x0, 0x0, 0x22, + 0x3e, 0xff, 0xff, 0xff, 0xa4, 0x0, 0x6, 0xf4, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xf4, + 0xbe, 0x51, 0x4, 0x9f, 0xff, 0xff, 0xff, 0xd1, + 0x81, 0x0, 0x0, 0x1, 0x6b, 0xef, 0xd7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00A0 " " */ + + /* U+00A3 "£" */ + 0x0, 0x0, 0x3, 0xad, 0xff, 0xd8, 0x10, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xe4, 0x0, + 0x0, 0xa, 0xff, 0xd6, 0x34, 0x9f, 0xff, 0x30, + 0x0, 0x4f, 0xfd, 0x0, 0x0, 0x5, 0xff, 0xc0, + 0x0, 0x9f, 0xf4, 0x0, 0x0, 0x0, 0xbf, 0xf2, + 0x0, 0xbf, 0xf0, 0x0, 0x0, 0x0, 0x5c, 0x92, + 0x0, 0xcf, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0x5f, 0xfc, 0x33, 0x33, 0x10, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x5, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0x61, 0x21, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xfd, 0xb9, 0x9b, 0xe4, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0xb, 0x94, 0x10, 0x2, 0x58, 0xce, 0xfd, 0xa5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00A4 "¤" */ + 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x2, + 0xeb, 0x0, 0x25, 0x64, 0x0, 0x2e, 0xb0, 0x9f, + 0xfb, 0xbf, 0xff, 0xff, 0x9e, 0xff, 0x40, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0xff, + 0xf7, 0x10, 0x3b, 0xff, 0xa0, 0x0, 0x6f, 0xf5, + 0x0, 0x0, 0xa, 0xff, 0x10, 0xb, 0xfc, 0x0, + 0x0, 0x0, 0x2f, 0xf6, 0x0, 0xdf, 0x80, 0x0, + 0x0, 0x0, 0xef, 0x80, 0xc, 0xf9, 0x0, 0x0, + 0x0, 0xf, 0xf7, 0x0, 0x9f, 0xe0, 0x0, 0x0, + 0x5, 0xff, 0x40, 0x3, 0xff, 0xa0, 0x0, 0x2, + 0xef, 0xe0, 0x0, 0x2f, 0xff, 0xd8, 0x69, 0xff, + 0xfc, 0x0, 0x2e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfb, 0x8, 0xff, 0x43, 0xbe, 0xfe, 0x91, 0x9f, + 0xf4, 0x9, 0x50, 0x0, 0x0, 0x0, 0x0, 0x95, + 0x0, + + /* U+00A5 "¥" */ + 0xbf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0x62, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xd0, 0x9, 0xff, 0x40, 0x0, 0x0, 0x0, 0xcf, + 0xf4, 0x0, 0x1f, 0xfd, 0x0, 0x0, 0x0, 0x4f, + 0xfb, 0x0, 0x0, 0x8f, 0xf5, 0x0, 0x0, 0xd, + 0xff, 0x30, 0x0, 0x0, 0xef, 0xe0, 0x0, 0x5, + 0xff, 0xa0, 0x0, 0x0, 0x6, 0xff, 0x70, 0x0, + 0xdf, 0xf1, 0x0, 0x0, 0x0, 0xd, 0xfe, 0x10, + 0x6f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf8, + 0xe, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xf7, 0xff, 0x70, 0x0, 0x0, 0x3, 0x33, 0x36, + 0xff, 0xff, 0xe3, 0x33, 0x32, 0x0, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0xf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0x11, 0x11, 0x11, 0xff, 0xb1, 0x11, 0x11, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xb0, + 0x0, 0x0, 0x0, + + /* U+00A6 "¦" */ + 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, + 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, + 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, 0x2a, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2a, 0xa0, 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, + 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, + 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, 0x4f, 0xf0, + + /* U+00A7 "§" */ + 0x0, 0x0, 0x7d, 0xff, 0xda, 0x30, 0x0, 0x0, + 0x1, 0xdf, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0xbf, 0xfa, 0x43, 0x7f, 0xff, 0x40, 0x0, 0x2f, + 0xf9, 0x0, 0x0, 0x4f, 0xfb, 0x0, 0x5, 0xff, + 0x40, 0x0, 0x0, 0xdf, 0xf0, 0x0, 0x3f, 0xf9, + 0x0, 0x0, 0x3, 0x32, 0x0, 0x0, 0xdf, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfa, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x4d, 0xff, 0xfe, + 0x50, 0x0, 0x0, 0x0, 0x8f, 0xf7, 0xbf, 0xff, + 0xb2, 0x0, 0x0, 0x4f, 0xf4, 0x0, 0x6f, 0xff, + 0xf6, 0x0, 0x9, 0xfc, 0x0, 0x0, 0x1b, 0xff, + 0xfa, 0x0, 0xbf, 0xb0, 0x0, 0x0, 0x6, 0xff, + 0xf9, 0x9, 0xff, 0x20, 0x0, 0x0, 0x3, 0xff, + 0xf1, 0x3f, 0xfd, 0x20, 0x0, 0x0, 0x6, 0xff, + 0x50, 0x8f, 0xff, 0x60, 0x0, 0x0, 0x2f, 0xf4, + 0x0, 0x6f, 0xff, 0xc2, 0x0, 0x6, 0xff, 0x10, + 0x0, 0x3d, 0xff, 0xf8, 0x3, 0xef, 0x70, 0x0, + 0x0, 0x7, 0xff, 0xfe, 0xfd, 0x50, 0x0, 0x0, + 0x0, 0x2, 0xcf, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0x0, 0x4, 0x78, 0x0, + 0x0, 0x0, 0x8f, 0xf4, 0x0, 0xbf, 0xf2, 0x0, + 0x0, 0x5, 0xff, 0x50, 0x6, 0xff, 0xb0, 0x0, + 0x0, 0xbf, 0xf2, 0x0, 0xd, 0xff, 0xd6, 0x45, + 0xcf, 0xfb, 0x0, 0x0, 0x2d, 0xff, 0xff, 0xff, + 0xfc, 0x10, 0x0, 0x0, 0x6, 0xbe, 0xfe, 0xc6, + 0x0, 0x0, + + /* U+00A8 "¨" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xfa, 0x0, + 0xaf, 0xf1, 0x1f, 0xfa, 0x0, 0xaf, 0xf1, 0x1f, + 0xfa, 0x0, 0xaf, 0xf1, + + /* U+00A9 "©" */ + 0x0, 0x0, 0x0, 0x6, 0xad, 0xff, 0xdb, 0x61, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7e, 0xff, + 0xfe, 0xdf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xdf, 0xf8, 0x30, 0x0, 0x3, 0x8e, 0xfd, + 0x20, 0x0, 0x0, 0x1, 0xef, 0xb1, 0x0, 0x0, + 0x0, 0x0, 0x1b, 0xfe, 0x20, 0x0, 0x0, 0xdf, + 0x90, 0x0, 0x27, 0x99, 0x72, 0x0, 0x8, 0xfd, + 0x10, 0x0, 0x7f, 0xb0, 0x0, 0x8f, 0xff, 0xff, + 0xf9, 0x0, 0xa, 0xf9, 0x0, 0x1f, 0xf1, 0x0, + 0x7f, 0xe5, 0x10, 0x4d, 0xf8, 0x0, 0xe, 0xf2, + 0x6, 0xf8, 0x0, 0x1f, 0xf3, 0x0, 0x0, 0x1e, + 0xe0, 0x0, 0x7f, 0x80, 0xbf, 0x30, 0x7, 0xfa, + 0x0, 0x0, 0x0, 0x20, 0x0, 0x1, 0xfc, 0xe, + 0xf0, 0x0, 0xaf, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xf0, 0xfd, 0x0, 0xb, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0x1f, 0xd0, + 0x0, 0xaf, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xf0, 0xdf, 0x0, 0x8, 0xf8, 0x0, 0x0, + 0x0, 0x45, 0x0, 0x0, 0xdf, 0xb, 0xf3, 0x0, + 0x3f, 0xe0, 0x0, 0x0, 0xd, 0xf3, 0x0, 0x1f, + 0xc0, 0x6f, 0x80, 0x0, 0xbf, 0xa1, 0x0, 0x1b, + 0xfc, 0x0, 0x6, 0xf8, 0x1, 0xff, 0x10, 0x1, + 0xdf, 0xfc, 0xcf, 0xfd, 0x10, 0x0, 0xef, 0x20, + 0x8, 0xfb, 0x0, 0x0, 0x7c, 0xff, 0xd7, 0x0, + 0x0, 0x9f, 0x90, 0x0, 0xc, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xd1, 0x0, 0x0, + 0x1e, 0xfb, 0x10, 0x0, 0x0, 0x0, 0x1, 0xaf, + 0xe2, 0x0, 0x0, 0x0, 0x1c, 0xff, 0x83, 0x0, + 0x0, 0x38, 0xef, 0xd2, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xee, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x6b, 0xdf, 0xfd, + 0xb6, 0x10, 0x0, 0x0, 0x0, + + /* U+00AA "ª" */ + 0x0, 0x4c, 0xff, 0xb2, 0x7f, 0xa0, 0x5f, 0xfc, + 0xbf, 0xec, 0xf6, 0xe, 0xf8, 0x0, 0x2f, 0xff, + 0x25, 0xff, 0x0, 0x0, 0x8f, 0xe0, 0x7f, 0xc0, + 0x0, 0x5, 0xfb, 0x8, 0xfb, 0x0, 0x0, 0x4f, + 0x90, 0x7f, 0xc0, 0x0, 0x5, 0xfb, 0x4, 0xff, + 0x0, 0x0, 0xaf, 0xe0, 0xe, 0xf7, 0x0, 0x3f, + 0xff, 0x10, 0x4f, 0xfb, 0xaf, 0xec, 0xf6, 0x0, + 0x4c, 0xff, 0xb2, 0x6f, 0xa0, + + /* U+00AB "«" */ + 0x0, 0x0, 0x37, 0x50, 0x0, 0x57, 0x30, 0x0, + 0x1e, 0xf5, 0x0, 0x4f, 0xf1, 0x0, 0xa, 0xfc, + 0x0, 0x1e, 0xf7, 0x0, 0x5, 0xff, 0x30, 0xa, + 0xfd, 0x0, 0x1, 0xef, 0x90, 0x5, 0xff, 0x40, + 0x0, 0xbf, 0xf1, 0x1, 0xef, 0xb0, 0x0, 0x7f, + 0xf7, 0x0, 0xbf, 0xf2, 0x0, 0xc, 0xff, 0x30, + 0x1f, 0xfd, 0x0, 0x0, 0x2f, 0xfb, 0x0, 0x6f, + 0xf6, 0x0, 0x0, 0x7f, 0xf4, 0x0, 0xbf, 0xe1, + 0x0, 0x0, 0xbf, 0xd0, 0x1, 0xef, 0x80, 0x0, + 0x1, 0xff, 0x60, 0x5, 0xff, 0x20, 0x0, 0x5, + 0xfe, 0x0, 0xa, 0xfb, 0x0, 0x0, 0xa, 0xf8, + 0x0, 0x1e, 0xf4, + + /* U+00AC "¬" */ + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd5, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x27, + 0x77, 0x77, 0x77, 0x77, 0x77, 0xcf, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xd0, + + /* U+00AD "­" */ + 0xa, 0xaa, 0xaa, 0xaa, 0xa0, 0xf, 0xff, 0xff, + 0xff, 0xf0, 0xf, 0xff, 0xff, 0xff, 0xf0, + + /* U+00AE "®" */ + 0x0, 0x0, 0x0, 0x6, 0xad, 0xff, 0xdb, 0x61, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7e, 0xff, + 0xfe, 0xdf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xdf, 0xf8, 0x30, 0x0, 0x3, 0x8e, 0xfd, + 0x20, 0x0, 0x0, 0x1, 0xef, 0xb1, 0x0, 0x0, + 0x0, 0x0, 0x1b, 0xfe, 0x20, 0x0, 0x0, 0xdf, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xfd, + 0x10, 0x0, 0x7f, 0xb0, 0xc, 0xff, 0xff, 0xfd, + 0x80, 0x0, 0xa, 0xf9, 0x0, 0x1f, 0xf1, 0x0, + 0xcf, 0xaa, 0xab, 0xff, 0xb0, 0x0, 0xe, 0xf2, + 0x6, 0xf8, 0x0, 0xc, 0xf2, 0x0, 0x1, 0xef, + 0x30, 0x0, 0x7f, 0x80, 0xbf, 0x30, 0x0, 0xcf, + 0x20, 0x0, 0xb, 0xf5, 0x0, 0x1, 0xfc, 0xe, + 0xf0, 0x0, 0xc, 0xf2, 0x0, 0x2, 0xef, 0x10, + 0x0, 0xd, 0xf0, 0xfd, 0x0, 0x0, 0xcf, 0xba, + 0xac, 0xff, 0x70, 0x0, 0x0, 0xcf, 0x1f, 0xd0, + 0x0, 0xc, 0xff, 0xff, 0xfa, 0x40, 0x0, 0x0, + 0xc, 0xf0, 0xdf, 0x0, 0x0, 0xcf, 0x20, 0x4e, + 0xe2, 0x0, 0x0, 0x0, 0xdf, 0xb, 0xf3, 0x0, + 0xc, 0xf2, 0x0, 0x4f, 0xd0, 0x0, 0x0, 0x1f, + 0xc0, 0x6f, 0x80, 0x0, 0xcf, 0x20, 0x0, 0x9f, + 0x90, 0x0, 0x6, 0xf8, 0x1, 0xff, 0x10, 0xc, + 0xf2, 0x0, 0x1, 0xff, 0x30, 0x0, 0xef, 0x20, + 0x8, 0xfb, 0x0, 0xcf, 0x20, 0x0, 0x7, 0xfd, + 0x0, 0x9f, 0x90, 0x0, 0xc, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xd1, 0x0, 0x0, + 0x1e, 0xfb, 0x10, 0x0, 0x0, 0x0, 0x1, 0xaf, + 0xe2, 0x0, 0x0, 0x0, 0x1c, 0xff, 0x83, 0x0, + 0x0, 0x38, 0xef, 0xd2, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xee, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x6b, 0xdf, 0xfd, + 0xb6, 0x10, 0x0, 0x0, 0x0, + + /* U+00B0 "°" */ + 0x0, 0x2b, 0xff, 0xb2, 0x0, 0x2, 0xff, 0xab, + 0xff, 0x20, 0xb, 0xf3, 0x0, 0x3f, 0xb0, 0xf, + 0xa0, 0x0, 0xa, 0xf0, 0xf, 0xa0, 0x0, 0xa, + 0xf0, 0xb, 0xf2, 0x0, 0x3f, 0xb0, 0x2, 0xff, + 0xab, 0xff, 0x30, 0x0, 0x2b, 0xff, 0xb2, 0x0, + + /* U+00B1 "±" */ + 0x0, 0x0, 0x0, 0x7f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd5, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x27, 0x77, 0x77, 0xbf, + 0xf7, 0x77, 0x77, 0x60, 0x0, 0x0, 0x7, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x24, 0x40, 0x0, 0x0, + 0x2, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x76, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd5, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + + /* U+00B2 "²" */ + 0x0, 0x5c, 0xef, 0xe9, 0x10, 0x8, 0xff, 0xcc, + 0xff, 0xe0, 0x1f, 0xf5, 0x0, 0x2f, 0xf5, 0x3, + 0x50, 0x0, 0xe, 0xf5, 0x0, 0x0, 0x0, 0x6f, + 0xf1, 0x0, 0x0, 0x8, 0xff, 0x50, 0x0, 0x1, + 0xcf, 0xf4, 0x0, 0x0, 0x3e, 0xfc, 0x20, 0x0, + 0x3, 0xff, 0x90, 0x0, 0x0, 0x1e, 0xff, 0xcc, + 0xcc, 0xc6, 0x8f, 0xff, 0xff, 0xff, 0xf7, + + /* U+00B3 "³" */ + 0x0, 0x7d, 0xff, 0xd8, 0x0, 0xa, 0xff, 0xab, + 0xff, 0xb0, 0x1b, 0xd2, 0x0, 0x6f, 0xe0, 0x0, + 0x0, 0x2, 0xbf, 0xa0, 0x0, 0x0, 0xbf, 0xf9, + 0x0, 0x0, 0x0, 0x8a, 0xef, 0x80, 0x0, 0x0, + 0x0, 0x1f, 0xf4, 0x15, 0x40, 0x0, 0xe, 0xf6, + 0x4f, 0xf2, 0x0, 0x5f, 0xf4, 0xb, 0xff, 0xcd, + 0xff, 0xb0, 0x0, 0x7d, 0xff, 0xc6, 0x0, + + /* U+00B5 "µ" */ + 0xff, 0xa0, 0x0, 0x0, 0x0, 0xff, 0xaf, 0xfa, + 0x0, 0x0, 0x0, 0xf, 0xfa, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0xff, 0xaf, 0xfa, 0x0, 0x0, 0x0, + 0xf, 0xfa, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xff, + 0xaf, 0xfa, 0x0, 0x0, 0x0, 0xf, 0xfa, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0xff, 0xaf, 0xfa, 0x0, + 0x0, 0x0, 0xf, 0xfa, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0xff, 0xaf, 0xfb, 0x0, 0x0, 0x0, 0xf, + 0xfa, 0xff, 0xd0, 0x0, 0x0, 0x2, 0xff, 0xaf, + 0xff, 0x20, 0x0, 0x0, 0x7f, 0xfa, 0xff, 0xfc, + 0x0, 0x0, 0x3f, 0xff, 0xaf, 0xff, 0xfe, 0x87, + 0xaf, 0xff, 0xfa, 0xff, 0xce, 0xff, 0xff, 0xfb, + 0xbf, 0xaf, 0xfa, 0x19, 0xef, 0xd7, 0xb, 0xfa, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00B6 "¶" */ + 0x0, 0x0, 0x6b, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xf2, 0x0, 0x2d, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf2, 0x0, 0xdf, 0xff, 0xff, 0xfa, 0x88, + 0xcf, 0xf8, 0x81, 0x7, 0xff, 0xff, 0xff, 0xf4, + 0x0, 0x7f, 0xf0, 0x0, 0xd, 0xff, 0xff, 0xff, + 0xf4, 0x0, 0x7f, 0xf0, 0x0, 0xf, 0xff, 0xff, + 0xff, 0xf4, 0x0, 0x7f, 0xf0, 0x0, 0xf, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0x7f, 0xf0, 0x0, 0xf, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x7f, 0xf0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x7f, 0xf0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x7f, + 0xf0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf4, 0x0, + 0x7f, 0xf0, 0x0, 0x0, 0x5, 0xdf, 0xff, 0xf4, + 0x0, 0x7f, 0xf0, 0x0, 0x0, 0x0, 0x2, 0x5f, + 0xf4, 0x0, 0x7f, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xf4, 0x0, 0x7f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xf4, 0x0, 0x7f, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xf4, 0x0, 0x7f, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xf4, 0x0, 0x7f, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xf4, 0x0, 0x7f, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xf4, 0x0, + 0x7f, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xf4, + 0x0, 0x7f, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xf4, 0x0, 0x7f, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xf4, 0x0, 0x7f, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xf4, 0x0, 0x7f, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xf4, 0x0, 0x7f, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xf4, 0x0, 0x7f, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xf4, 0x0, 0x7f, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xf4, 0x0, + 0x7f, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xf4, + 0x0, 0x7f, 0xf0, 0x0, + + /* U+00B7 "·" */ + 0x0, 0x0, 0x4f, 0xfb, 0x4f, 0xfb, 0x4f, 0xfb, + + /* U+00BB "»" */ + 0x57, 0x30, 0x0, 0x66, 0x0, 0x0, 0x5, 0xfe, + 0x10, 0xa, 0xfa, 0x0, 0x0, 0xc, 0xfa, 0x0, + 0x1f, 0xf5, 0x0, 0x0, 0x3f, 0xf5, 0x0, 0x8f, + 0xe1, 0x0, 0x0, 0x9f, 0xe1, 0x0, 0xef, 0xb0, + 0x0, 0x1, 0xff, 0xb0, 0x5, 0xff, 0x60, 0x0, + 0x7, 0xff, 0x60, 0xc, 0xff, 0x20, 0x0, 0x3f, + 0xfb, 0x0, 0x8f, 0xf7, 0x0, 0xb, 0xff, 0x20, + 0x1f, 0xfc, 0x0, 0x4, 0xff, 0x60, 0x9, 0xff, + 0x20, 0x0, 0xdf, 0xb0, 0x2, 0xff, 0x60, 0x0, + 0x7f, 0xe1, 0x0, 0xbf, 0xb0, 0x0, 0x1f, 0xf5, + 0x0, 0x4f, 0xe1, 0x0, 0x9, 0xfa, 0x0, 0xd, + 0xf5, 0x0, 0x0, + + /* U+00BD "½" */ + 0x0, 0x0, 0x12, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x12, 0x10, 0x0, 0x0, 0x3, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0x40, 0x0, + 0x0, 0x6f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xf9, 0x0, 0x0, 0x2c, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xd0, 0x0, 0x0, + 0x7f, 0xb4, 0xff, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0x20, 0x0, 0x0, 0x22, 0x2, 0xff, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0x0, + 0x0, 0x0, 0x4, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0x0, 0x0, 0x0, 0x1e, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0x0, + 0x0, 0x0, 0xbf, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0x0, 0x0, 0x6, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0x0, + 0x0, 0x2f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0x70, 0x0, + 0x5c, 0xef, 0xe9, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xfb, 0x0, 0x8, 0xff, 0xdc, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xe1, 0x0, 0x1f, + 0xf5, 0x0, 0x2f, 0xf5, 0x0, 0x0, 0x0, 0x1, + 0xef, 0x50, 0x0, 0x4, 0x50, 0x0, 0xe, 0xf5, + 0x0, 0x0, 0x0, 0xa, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xf1, 0x0, 0x0, 0x0, 0x6f, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x50, + 0x0, 0x0, 0x2, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x1, 0xbf, 0xf5, 0x0, 0x0, 0x0, 0xc, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x3e, 0xfd, 0x20, 0x0, + 0x0, 0x0, 0x8f, 0xc0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x3, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xcc, 0xcc, 0xc6, + 0x0, 0x1e, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x38, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0384 "΄" */ + 0x0, 0x12, 0x21, 0x1, 0xff, 0xf3, 0x9, 0xff, + 0x60, 0x1f, 0xf9, 0x0, 0x8f, 0xc0, 0x0, + + /* U+0386 "Ά" */ + 0x0, 0x8, 0xff, 0xc0, 0xe, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xfe, 0x10, 0x5f, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xf4, 0x0, 0xbf, 0xdf, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0x70, 0x1, 0xff, 0x6e, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x21, 0x0, 0x7, + 0xff, 0x29, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xfd, 0x4, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf8, 0x0, + 0xef, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf2, 0x0, 0x8f, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xd0, 0x0, 0x2f, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0x70, + 0x0, 0xd, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0x10, 0x0, 0x7, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xfb, 0x0, 0x0, 0x1, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf5, + 0x0, 0x0, 0x0, 0xbf, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x9, 0xff, + 0x75, 0x55, 0x55, 0x55, 0x5a, 0xff, 0x70, 0x0, + 0x0, 0xe, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xd0, 0x0, 0x0, 0x5f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf4, 0x0, 0x0, 0xbf, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfa, + 0x0, 0x1, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x10, 0x7, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0x70, 0xd, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xd0, + + /* U+0388 "Έ" */ + 0x0, 0x9f, 0xfb, 0x2, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf6, 0x1, 0xff, 0xd1, 0x2, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, + 0x8, 0xff, 0x20, 0x2, 0xff, 0xd8, 0x88, 0x88, + 0x88, 0x88, 0x88, 0x83, 0xf, 0xf5, 0x0, 0x2, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x10, 0x0, 0x2, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xd8, 0x88, 0x88, 0x88, 0x88, 0x88, 0x50, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xd8, 0x88, 0x88, 0x88, 0x88, 0x88, 0x87, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + + /* U+0389 "Ή" */ + 0x0, 0x9f, 0xfb, 0xb, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0x20, 0x1f, 0xfd, 0x10, + 0xbf, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xf2, 0x8, 0xff, 0x30, 0xb, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0x20, 0xff, 0x60, + 0x0, 0xbf, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf2, 0x2, 0x10, 0x0, 0xb, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0x20, 0x0, + 0x0, 0x0, 0xbf, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xf2, 0x0, 0x0, 0x0, 0xb, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0x20, + 0x0, 0x0, 0x0, 0xbf, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xf2, 0x0, 0x0, 0x0, 0xb, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0x20, 0x0, 0x0, 0x0, 0xbf, 0xf9, 0x88, 0x88, + 0x88, 0x88, 0x88, 0xdf, 0xf2, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0xb, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0x20, 0x0, 0x0, 0x0, 0xbf, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf2, 0x0, + 0x0, 0x0, 0xb, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0x20, 0x0, 0x0, 0x0, 0xbf, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf2, + 0x0, 0x0, 0x0, 0xb, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0x20, 0x0, 0x0, 0x0, + 0xbf, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xf2, 0x0, 0x0, 0x0, 0xb, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0x20, 0x0, 0x0, + 0x0, 0xbf, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf2, 0x0, 0x0, 0x0, 0xb, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0x20, 0x0, + 0x0, 0x0, 0xbf, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xf2, + + /* U+038A "Ί" */ + 0x0, 0x9f, 0xfb, 0xb, 0xff, 0x10, 0x1f, 0xfd, + 0x10, 0xbf, 0xf1, 0x8, 0xff, 0x30, 0xb, 0xff, + 0x10, 0xff, 0x60, 0x0, 0xbf, 0xf1, 0x2, 0x10, + 0x0, 0xb, 0xff, 0x10, 0x0, 0x0, 0x0, 0xbf, + 0xf1, 0x0, 0x0, 0x0, 0xb, 0xff, 0x10, 0x0, + 0x0, 0x0, 0xbf, 0xf1, 0x0, 0x0, 0x0, 0xb, + 0xff, 0x10, 0x0, 0x0, 0x0, 0xbf, 0xf1, 0x0, + 0x0, 0x0, 0xb, 0xff, 0x10, 0x0, 0x0, 0x0, + 0xbf, 0xf1, 0x0, 0x0, 0x0, 0xb, 0xff, 0x10, + 0x0, 0x0, 0x0, 0xbf, 0xf1, 0x0, 0x0, 0x0, + 0xb, 0xff, 0x10, 0x0, 0x0, 0x0, 0xbf, 0xf1, + 0x0, 0x0, 0x0, 0xb, 0xff, 0x10, 0x0, 0x0, + 0x0, 0xbf, 0xf1, 0x0, 0x0, 0x0, 0xb, 0xff, + 0x10, 0x0, 0x0, 0x0, 0xbf, 0xf1, 0x0, 0x0, + 0x0, 0xb, 0xff, 0x10, 0x0, 0x0, 0x0, 0xbf, + 0xf1, + + /* U+038C "Ό" */ + 0x0, 0x9f, 0xfb, 0x0, 0x3, 0x8c, 0xef, 0xed, + 0x94, 0x0, 0x0, 0x0, 0x1, 0xff, 0xd1, 0x2, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xc3, 0x0, 0x0, + 0x8, 0xff, 0x20, 0x4f, 0xff, 0xfc, 0x87, 0x8b, + 0xff, 0xff, 0x50, 0x0, 0xf, 0xf5, 0x3, 0xff, + 0xfa, 0x10, 0x0, 0x0, 0x19, 0xff, 0xf4, 0x0, + 0x2, 0x10, 0x1e, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xfe, 0x10, 0x0, 0x0, 0x7f, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0x90, + 0x0, 0x0, 0xef, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xf1, 0x0, 0x3, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf5, + 0x0, 0x7, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xf9, 0x0, 0x9, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfb, + 0x0, 0xa, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xfc, 0x0, 0xb, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xfc, + 0x0, 0xa, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xfb, 0x0, 0x7, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf9, + 0x0, 0x3, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf5, 0x0, 0x0, 0xef, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf1, + 0x0, 0x0, 0x8f, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0x90, 0x0, 0x0, 0x1e, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x20, + 0x0, 0x0, 0x4, 0xff, 0xfa, 0x10, 0x0, 0x0, + 0x19, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xfb, 0x87, 0x8b, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xc3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0x9c, 0xff, 0xed, 0x94, 0x0, 0x0, 0x0, + + /* U+038E "Ύ" */ + 0x0, 0x9f, 0xfb, 0x2, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xd0, 0x1, 0xff, + 0xd1, 0x0, 0x7f, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0x30, 0x8, 0xff, 0x20, 0x0, + 0xc, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xf8, 0x0, 0xf, 0xf5, 0x0, 0x0, 0x2, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x5, 0xff, 0xd0, 0x0, + 0x2, 0x10, 0x0, 0x0, 0x0, 0x7f, 0xfd, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0x80, 0x0, 0x0, + 0x9f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf3, 0x0, 0x4, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xfc, 0x0, 0xd, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0x60, 0x8f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xe3, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, + + /* U+038F "Ώ" */ + 0x0, 0x9f, 0xfb, 0x0, 0x4, 0x9d, 0xff, 0xfc, + 0x93, 0x0, 0x0, 0x0, 0x1, 0xff, 0xd1, 0x1, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xa1, 0x0, 0x0, + 0x8, 0xff, 0x20, 0x3e, 0xff, 0xfb, 0x87, 0x8d, + 0xff, 0xfd, 0x10, 0x0, 0xf, 0xf5, 0x1, 0xef, + 0xfc, 0x20, 0x0, 0x0, 0x4e, 0xff, 0xc0, 0x0, + 0x2, 0x10, 0xa, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x2, 0xef, 0xf7, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfe, 0x0, + 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0x50, 0x0, 0x0, 0xef, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xa0, + 0x0, 0x1, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xc0, 0x0, 0x2, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xe0, + 0x0, 0x3, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xe0, 0x0, 0x2, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xd0, + 0x0, 0x0, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xb0, 0x0, 0x0, 0xcf, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0x70, + 0x0, 0x0, 0x6f, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0x20, 0x0, 0x0, 0xe, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xfb, 0x0, + 0x0, 0x0, 0x6, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xe2, 0x0, 0x0, 0x0, 0x4, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xfe, 0x40, 0x0, 0x0, + 0x6f, 0xf7, 0x0, 0x0, 0x0, 0x3, 0x88, 0x89, + 0xff, 0xf9, 0x0, 0x1c, 0xff, 0xe8, 0x88, 0x81, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xff, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xf2, + + /* U+0390 "ΐ" */ + 0x0, 0x0, 0xd, 0xfb, 0x0, 0xf, 0xf8, 0x5, + 0xfe, 0x1e, 0xfa, 0xff, 0x80, 0xdf, 0x30, 0xef, + 0xad, 0xd7, 0x3d, 0x60, 0xb, 0xd8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0xf, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xf, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xf, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, + 0x0, + + /* U+0391 "Α" */ + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xef, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0x6e, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0x29, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xfd, 0x4, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf8, 0x0, + 0xef, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf3, 0x0, 0x8f, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xd0, 0x0, 0x3f, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0x70, + 0x0, 0xd, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0x10, 0x0, 0x7, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xfb, 0x0, 0x0, 0x1, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf5, + 0x0, 0x0, 0x0, 0xbf, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x9, 0xff, + 0x75, 0x55, 0x55, 0x55, 0x5a, 0xff, 0x70, 0x0, + 0x0, 0xe, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xd0, 0x0, 0x0, 0x5f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf4, 0x0, 0x0, 0xbf, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfa, + 0x0, 0x1, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x10, 0x7, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0x70, 0xd, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xd0, + + /* U+0392 "Β" */ + 0xcf, 0xff, 0xff, 0xff, 0xfe, 0xc8, 0x20, 0x0, + 0xc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, + 0x0, 0xcf, 0xf9, 0x88, 0x88, 0x9b, 0xef, 0xff, + 0x50, 0xc, 0xff, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xfe, 0x0, 0xcf, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xf3, 0xc, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0x50, 0xcf, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xf4, 0xc, 0xff, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0x10, 0xcf, 0xf0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0x90, 0xc, 0xff, 0x99, 0x99, + 0x99, 0xae, 0xff, 0xb0, 0x0, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc1, 0x0, 0xc, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0xcf, 0xf0, + 0x0, 0x0, 0x1, 0x38, 0xff, 0xf5, 0xc, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xe0, 0xcf, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0x4c, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf6, + 0xcf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0x5c, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xf2, 0xcf, 0xf0, 0x0, 0x0, 0x0, 0x1, 0xaf, + 0xfc, 0xc, 0xff, 0x98, 0x88, 0x88, 0x9b, 0xff, + 0xff, 0x30, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x40, 0xc, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0xa6, 0x0, 0x0, + + /* U+0393 "Γ" */ + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x9f, 0xfa, + 0x88, 0x88, 0x88, 0x88, 0x87, 0x9f, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0394 "Δ" */ + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xef, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0x6e, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0x2a, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xfd, 0x4, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf8, 0x0, + 0xef, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf2, 0x0, 0x9f, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xd0, 0x0, 0x3f, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0x70, + 0x0, 0xd, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0x10, 0x0, 0x7, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xfc, 0x0, 0x0, 0x1, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf6, + 0x0, 0x0, 0x0, 0xbf, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xf1, 0x0, 0x0, 0x0, 0x5f, 0xfa, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0x10, 0x0, 0x0, 0x9, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x9, 0xff, 0x70, 0x0, + 0x0, 0xe, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xd0, 0x0, 0x0, 0x5f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf4, 0x0, 0x0, 0xbf, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfa, + 0x0, 0x1, 0xff, 0xf8, 0x88, 0x88, 0x88, 0x88, + 0x88, 0xaf, 0xff, 0x10, 0x7, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0xd, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd0, + + /* U+0395 "Ε" */ + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe0, 0xaf, 0xfa, 0x88, 0x88, 0x88, 0x88, 0x88, + 0x87, 0xa, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xa8, 0x88, + 0x88, 0x88, 0x88, 0x88, 0x0, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf1, 0xa, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x10, 0xaf, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xa8, 0x88, 0x88, 0x88, 0x88, + 0x88, 0x83, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x6a, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf6, + + /* U+0396 "Ζ" */ + 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf2, 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf2, 0x1, 0x88, 0x88, 0x88, 0x88, 0x88, + 0x8b, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2e, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xfe, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x98, 0x88, 0x88, + 0x88, 0x88, 0x88, 0x84, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf8, 0x7f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + + /* U+0397 "Η" */ + 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xf4, 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf4, 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xf4, 0x9f, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf4, 0x9f, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x9f, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x9f, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x9f, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, + 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xf4, 0x9f, 0xfa, 0x88, 0x88, 0x88, 0x88, 0x88, + 0xdf, 0xf4, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf4, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x9f, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x9f, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x9f, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x9f, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, + 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xf4, 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf4, 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xf4, 0x9f, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf4, 0x9f, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x9f, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, + + /* U+0398 "Θ" */ + 0x0, 0x0, 0x0, 0x38, 0xce, 0xfe, 0xd9, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xd4, 0x0, 0x0, 0x0, 0x3, 0xef, + 0xff, 0xc9, 0x78, 0xaf, 0xff, 0xf7, 0x0, 0x0, + 0x2, 0xff, 0xfb, 0x20, 0x0, 0x0, 0x8, 0xff, + 0xf6, 0x0, 0x0, 0xdf, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf3, 0x0, 0x6f, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xb0, 0xd, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0x21, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xf7, 0x5f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xb7, 0xff, + 0x70, 0x4, 0x88, 0x88, 0x88, 0x87, 0x0, 0x1f, + 0xfd, 0x8f, 0xf6, 0x0, 0x9f, 0xff, 0xff, 0xff, + 0xe0, 0x0, 0xff, 0xe9, 0xff, 0x50, 0x9, 0xff, + 0xff, 0xff, 0xfe, 0x0, 0xf, 0xfe, 0x8f, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xd5, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xfb, 0x2f, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0x70, 0xcf, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf2, + 0x6, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfb, 0x0, 0xd, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0x30, 0x0, 0x2f, 0xff, + 0xb2, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x60, 0x0, + 0x0, 0x3e, 0xff, 0xfc, 0x87, 0x8a, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x1a, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x40, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x8c, 0xef, 0xed, 0x95, 0x0, 0x0, 0x0, + + /* U+0399 "Ι" */ + 0x4f, 0xf9, 0x4f, 0xf9, 0x4f, 0xf9, 0x4f, 0xf9, + 0x4f, 0xf9, 0x4f, 0xf9, 0x4f, 0xf9, 0x4f, 0xf9, + 0x4f, 0xf9, 0x4f, 0xf9, 0x4f, 0xf9, 0x4f, 0xf9, + 0x4f, 0xf9, 0x4f, 0xf9, 0x4f, 0xf9, 0x4f, 0xf9, + 0x4f, 0xf9, 0x4f, 0xf9, 0x4f, 0xf9, 0x4f, 0xf9, + 0x4f, 0xf9, 0x4f, 0xf9, + + /* U+039A "Κ" */ + 0xcf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xe2, 0xcf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xfe, 0x20, 0xcf, 0xf0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xe2, 0x0, 0xcf, 0xf0, 0x0, 0x0, 0x0, + 0xaf, 0xfe, 0x20, 0x0, 0xcf, 0xf0, 0x0, 0x0, + 0xa, 0xff, 0xe2, 0x0, 0x0, 0xcf, 0xf0, 0x0, + 0x0, 0xaf, 0xfe, 0x20, 0x0, 0x0, 0xcf, 0xf0, + 0x0, 0xa, 0xff, 0xe2, 0x0, 0x0, 0x0, 0xcf, + 0xf0, 0x0, 0x9f, 0xfd, 0x20, 0x0, 0x0, 0x0, + 0xcf, 0xf0, 0x9, 0xff, 0xd1, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xf0, 0x9f, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xf9, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfd, 0x2e, 0xff, + 0x60, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xd1, 0x5, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0xcf, 0xfd, 0x10, + 0x0, 0xaf, 0xfd, 0x0, 0x0, 0x0, 0xcf, 0xf1, + 0x0, 0x0, 0xe, 0xff, 0x90, 0x0, 0x0, 0xcf, + 0xf0, 0x0, 0x0, 0x4, 0xff, 0xf4, 0x0, 0x0, + 0xcf, 0xf0, 0x0, 0x0, 0x0, 0x9f, 0xfe, 0x10, + 0x0, 0xcf, 0xf0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xb0, 0x0, 0xcf, 0xf0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf7, 0x0, 0xcf, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0x30, 0xcf, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xd0, 0xcf, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf9, + + /* U+039B "Λ" */ + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xfa, 0xbf, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xf5, 0x6f, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf0, 0x1f, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xb0, 0xb, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0x50, 0x5, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xfe, 0x0, 0x0, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf9, 0x0, 0x0, + 0xaf, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf3, + 0x0, 0x0, 0x4f, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xd0, 0x0, 0x0, 0xe, 0xfd, 0x0, 0x0, + 0x0, 0x3, 0xff, 0x80, 0x0, 0x0, 0x9, 0xff, + 0x30, 0x0, 0x0, 0x9, 0xff, 0x20, 0x0, 0x0, + 0x4, 0xff, 0x90, 0x0, 0x0, 0xf, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xe0, 0x0, 0x0, 0x5f, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf5, 0x0, + 0x0, 0xbf, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xfb, 0x0, 0x2, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0x10, 0x8, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0x70, 0xe, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xd0, + 0x4f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xf3, 0xaf, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf9, + + /* U+039C "Μ" */ + 0xcf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xcc, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xfc, 0xcf, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xcc, + 0xff, 0xef, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xfc, 0xcf, 0xf9, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xfb, 0xff, 0xcc, 0xff, 0x4f, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0xef, 0x5f, 0xfc, 0xcf, + 0xf0, 0xef, 0xa0, 0x0, 0x0, 0x0, 0x4f, 0xf0, + 0xff, 0xcc, 0xff, 0x9, 0xff, 0x0, 0x0, 0x0, + 0x9, 0xfa, 0xf, 0xfc, 0xcf, 0xf0, 0x4f, 0xf4, + 0x0, 0x0, 0x0, 0xef, 0x50, 0xff, 0xcc, 0xff, + 0x0, 0xef, 0xa0, 0x0, 0x0, 0x4f, 0xf0, 0xf, + 0xfc, 0xcf, 0xf0, 0x9, 0xfe, 0x0, 0x0, 0x9, + 0xfa, 0x0, 0xff, 0xcc, 0xff, 0x0, 0x4f, 0xf4, + 0x0, 0x0, 0xef, 0x50, 0xf, 0xfc, 0xcf, 0xf0, + 0x0, 0xef, 0x90, 0x0, 0x4f, 0xf0, 0x0, 0xff, + 0xcc, 0xff, 0x0, 0x9, 0xfe, 0x0, 0x9, 0xfa, + 0x0, 0xf, 0xfc, 0xcf, 0xf0, 0x0, 0x4f, 0xf4, + 0x0, 0xef, 0x40, 0x0, 0xff, 0xcc, 0xff, 0x0, + 0x0, 0xef, 0x90, 0x4f, 0xf0, 0x0, 0xf, 0xfc, + 0xcf, 0xf0, 0x0, 0x9, 0xfe, 0x9, 0xfa, 0x0, + 0x0, 0xff, 0xcc, 0xff, 0x0, 0x0, 0x4f, 0xf3, + 0xef, 0x40, 0x0, 0xf, 0xfc, 0xcf, 0xf0, 0x0, + 0x0, 0xef, 0xcf, 0xe0, 0x0, 0x0, 0xff, 0xcc, + 0xff, 0x0, 0x0, 0xa, 0xff, 0xf9, 0x0, 0x0, + 0xf, 0xfc, 0xcf, 0xf0, 0x0, 0x0, 0x4f, 0xff, + 0x40, 0x0, 0x0, 0xff, 0xcc, 0xff, 0x0, 0x0, + 0x0, 0xff, 0xe0, 0x0, 0x0, 0xf, 0xfc, + + /* U+039D "Ν" */ + 0xaf, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xf4, 0xaf, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xf4, 0xaf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xf4, 0xaf, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf4, 0xaf, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x7f, 0xf4, 0xaf, 0xf7, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x7f, 0xf4, 0xaf, 0xf1, + 0xbf, 0xf8, 0x0, 0x0, 0x0, 0x7f, 0xf4, 0xaf, + 0xf1, 0x2f, 0xff, 0x30, 0x0, 0x0, 0x7f, 0xf4, + 0xaf, 0xf1, 0x7, 0xff, 0xd0, 0x0, 0x0, 0x7f, + 0xf4, 0xaf, 0xf1, 0x0, 0xcf, 0xf7, 0x0, 0x0, + 0x7f, 0xf4, 0xaf, 0xf1, 0x0, 0x2f, 0xff, 0x20, + 0x0, 0x7f, 0xf4, 0xaf, 0xf1, 0x0, 0x7, 0xff, + 0xc0, 0x0, 0x7f, 0xf4, 0xaf, 0xf1, 0x0, 0x0, + 0xcf, 0xf7, 0x0, 0x7f, 0xf4, 0xaf, 0xf1, 0x0, + 0x0, 0x3f, 0xff, 0x20, 0x7f, 0xf4, 0xaf, 0xf1, + 0x0, 0x0, 0x8, 0xff, 0xb0, 0x7f, 0xf4, 0xaf, + 0xf1, 0x0, 0x0, 0x0, 0xdf, 0xf6, 0x7f, 0xf4, + 0xaf, 0xf1, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x8f, + 0xf4, 0xaf, 0xf1, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xf4, 0xaf, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xf4, 0xaf, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf4, 0xaf, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf4, 0xaf, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xf4, + + /* U+039E "Ξ" */ + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0x8, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, + 0x88, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf2, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x20, 0x0, 0x58, + 0x88, 0x88, 0x88, 0x88, 0x88, 0x81, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, + 0x88, 0x87, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe6, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, + + /* U+039F "Ο" */ + 0x0, 0x0, 0x0, 0x38, 0xce, 0xfe, 0xd9, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xd4, 0x0, 0x0, 0x0, 0x3, 0xef, + 0xff, 0xc9, 0x78, 0xaf, 0xff, 0xf7, 0x0, 0x0, + 0x2, 0xff, 0xfb, 0x20, 0x0, 0x0, 0x8, 0xff, + 0xf6, 0x0, 0x0, 0xdf, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf3, 0x0, 0x6f, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xb0, 0xd, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0x21, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xf7, 0x5f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xb7, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xfd, 0x8f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xe9, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xfe, 0x8f, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xd5, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xfb, 0x2f, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0x70, 0xcf, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf2, + 0x6, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfb, 0x0, 0xd, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0x30, 0x0, 0x2f, 0xff, + 0xb2, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x60, 0x0, + 0x0, 0x3e, 0xff, 0xfc, 0x87, 0x8a, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x1a, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x40, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x8c, 0xef, 0xed, 0x95, 0x0, 0x0, 0x0, + + /* U+03A0 "Π" */ + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf4, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf4, 0x9f, 0xfa, 0x88, 0x88, 0x88, 0x88, + 0x88, 0xdf, 0xf4, 0x9f, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf4, 0x9f, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x9f, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x9f, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x9f, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, + 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xf4, 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf4, 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xf4, 0x9f, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf4, 0x9f, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x9f, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x9f, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x9f, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, + 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xf4, 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf4, 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xf4, 0x9f, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf4, 0x9f, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x9f, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, + + /* U+03A1 "Ρ" */ + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xec, 0x93, 0x0, + 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0xbf, 0xf9, 0x88, 0x88, 0x89, 0xad, 0xff, + 0xf8, 0xb, 0xff, 0x20, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xf2, 0xbf, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0x7b, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xfa, 0xbf, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xab, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xf9, 0xbf, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0x5b, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xe0, 0xbf, 0xf9, 0x88, + 0x88, 0x89, 0xbf, 0xff, 0xf5, 0xb, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xeb, 0x71, 0x0, 0xb, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+03A3 "Σ" */ + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, + 0xdf, 0xfc, 0x88, 0x88, 0x88, 0x88, 0x88, 0x60, + 0x4f, 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xef, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xfb, 0x88, 0x88, 0x88, 0x88, 0x88, 0x83, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, + + /* U+03A4 "Τ" */ + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x38, 0x88, 0x88, 0x8a, 0xff, 0xc8, + 0x88, 0x88, 0x85, 0x0, 0x0, 0x0, 0x4, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0x90, 0x0, 0x0, 0x0, + + /* U+03A5 "Υ" */ + 0x9f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xf7, 0xe, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xc0, 0x4, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x20, 0x0, 0xaf, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf6, 0x0, + 0x0, 0x1e, 0xff, 0x60, 0x0, 0x0, 0x6, 0xff, + 0xb0, 0x0, 0x0, 0x5, 0xff, 0xf1, 0x0, 0x0, + 0x1f, 0xff, 0x10, 0x0, 0x0, 0x0, 0xaf, 0xfb, + 0x0, 0x0, 0xbf, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0x50, 0x5, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xe0, 0xe, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf7, 0x8f, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf3, + 0x0, 0x0, 0x0, 0x0, + + /* U+03A6 "Φ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0x5a, 0xff, 0x94, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3b, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xa3, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x9f, 0xff, 0x94, 0x17, 0xff, + 0x61, 0x4a, 0xff, 0xfa, 0x0, 0x5, 0xff, 0xe2, + 0x0, 0x7, 0xff, 0x60, 0x0, 0x3f, 0xff, 0x60, + 0xe, 0xff, 0x30, 0x0, 0x7, 0xff, 0x60, 0x0, + 0x5, 0xff, 0xe0, 0x4f, 0xfb, 0x0, 0x0, 0x7, + 0xff, 0x60, 0x0, 0x0, 0xcf, 0xf4, 0x8f, 0xf6, + 0x0, 0x0, 0x7, 0xff, 0x60, 0x0, 0x0, 0x7f, + 0xf8, 0xbf, 0xf4, 0x0, 0x0, 0x7, 0xff, 0x60, + 0x0, 0x0, 0x4f, 0xfa, 0xbf, 0xf3, 0x0, 0x0, + 0x7, 0xff, 0x60, 0x0, 0x0, 0x3f, 0xfa, 0xaf, + 0xf4, 0x0, 0x0, 0x7, 0xff, 0x60, 0x0, 0x0, + 0x4f, 0xf9, 0x8f, 0xf8, 0x0, 0x0, 0x7, 0xff, + 0x60, 0x0, 0x0, 0x8f, 0xf6, 0x3f, 0xfd, 0x0, + 0x0, 0x7, 0xff, 0x60, 0x0, 0x0, 0xdf, 0xf2, + 0xc, 0xff, 0x80, 0x0, 0x7, 0xff, 0x60, 0x0, + 0x8, 0xff, 0xa0, 0x2, 0xff, 0xf9, 0x10, 0x7, + 0xff, 0x60, 0x0, 0x8f, 0xfe, 0x20, 0x0, 0x4f, + 0xff, 0xfa, 0x7a, 0xff, 0x97, 0xae, 0xff, 0xf3, + 0x0, 0x0, 0x2, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x20, 0x0, 0x0, 0x0, 0x4, 0x9d, + 0xef, 0xff, 0xfe, 0xc9, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + + /* U+03A7 "Χ" */ + 0x8, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xd0, 0x0, 0xdf, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0x20, 0x0, 0x2f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0xbf, 0xf6, 0x0, 0x0, 0x7, + 0xff, 0xd0, 0x0, 0x0, 0x7, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0xcf, 0xf9, 0x0, 0x0, 0x3f, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x40, 0x0, + 0xdf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xe1, 0xa, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xfa, 0x5f, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xef, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf7, 0x8f, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xc0, 0xd, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x20, 0x3, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf6, 0x0, 0x0, 0x7f, 0xfe, + 0x10, 0x0, 0x0, 0x9, 0xff, 0xb0, 0x0, 0x0, + 0xc, 0xff, 0xa0, 0x0, 0x0, 0x5f, 0xfe, 0x10, + 0x0, 0x0, 0x2, 0xff, 0xf5, 0x0, 0x1, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x10, + 0xc, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xc0, 0x8f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xf7, + + /* U+03A8 "Ψ" */ + 0x2f, 0xfb, 0x0, 0x0, 0x0, 0xef, 0xf0, 0x0, + 0x0, 0xa, 0xff, 0x32, 0xff, 0xb0, 0x0, 0x0, + 0xe, 0xff, 0x0, 0x0, 0x0, 0xaf, 0xf3, 0x2f, + 0xfb, 0x0, 0x0, 0x0, 0xef, 0xf0, 0x0, 0x0, + 0xa, 0xff, 0x32, 0xff, 0xb0, 0x0, 0x0, 0xe, + 0xff, 0x0, 0x0, 0x0, 0xaf, 0xf3, 0x2f, 0xfb, + 0x0, 0x0, 0x0, 0xef, 0xf0, 0x0, 0x0, 0xa, + 0xff, 0x32, 0xff, 0xb0, 0x0, 0x0, 0xe, 0xff, + 0x0, 0x0, 0x0, 0xaf, 0xf3, 0x2f, 0xfb, 0x0, + 0x0, 0x0, 0xef, 0xf0, 0x0, 0x0, 0xb, 0xff, + 0x31, 0xff, 0xc0, 0x0, 0x0, 0xe, 0xff, 0x0, + 0x0, 0x0, 0xcf, 0xf2, 0xf, 0xfe, 0x0, 0x0, + 0x0, 0xef, 0xf0, 0x0, 0x0, 0xe, 0xff, 0x0, + 0xcf, 0xf3, 0x0, 0x0, 0xe, 0xff, 0x0, 0x0, + 0x3, 0xff, 0xd0, 0x7, 0xff, 0xa0, 0x0, 0x0, + 0xef, 0xf0, 0x0, 0x0, 0xaf, 0xf8, 0x0, 0x1f, + 0xff, 0x80, 0x0, 0xe, 0xff, 0x0, 0x0, 0x7f, + 0xff, 0x10, 0x0, 0x6f, 0xff, 0xd6, 0x20, 0xef, + 0xf0, 0x25, 0xcf, 0xff, 0x60, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x3a, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x35, 0x6f, 0xff, 0x65, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A9 "Ω" */ + 0x0, 0x0, 0x0, 0x4a, 0xdf, 0xfe, 0xc8, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xdf, 0xff, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xb8, 0x79, 0xdf, 0xff, 0xb0, 0x0, 0x0, + 0x2, 0xff, 0xfb, 0x10, 0x0, 0x0, 0x6f, 0xff, + 0xa0, 0x0, 0x0, 0xcf, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x40, 0x0, 0x5f, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfd, 0x0, 0xc, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xf3, 0x0, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0x70, 0x3f, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfa, 0x4, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xb0, 0x5f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xfc, 0x4, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xb0, 0x2f, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf9, + 0x0, 0xef, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0x50, 0x8, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xf0, 0x0, 0x2f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf8, 0x0, + 0x0, 0x8f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xfe, 0x10, 0x0, 0x0, 0xcf, 0xd1, 0x0, 0x0, + 0x0, 0x6, 0xff, 0x40, 0x0, 0x0, 0x1, 0xdf, + 0xd2, 0x0, 0x0, 0x8, 0xff, 0x50, 0x0, 0x5, + 0x88, 0x89, 0xff, 0xf7, 0x0, 0x2d, 0xff, 0xc8, + 0x88, 0x80, 0x9f, 0xff, 0xff, 0xff, 0xc0, 0x5, + 0xff, 0xff, 0xff, 0xff, 0x9, 0xff, 0xff, 0xff, + 0xfc, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xf0, + + /* U+03AA "Ϊ" */ + 0xf, 0xfb, 0x0, 0x8f, 0xf3, 0xf, 0xfb, 0x0, + 0x8f, 0xf3, 0xf, 0xfb, 0x0, 0x8f, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0x90, + 0x0, 0x0, 0x4, 0xff, 0x90, 0x0, 0x0, 0x4, + 0xff, 0x90, 0x0, 0x0, 0x4, 0xff, 0x90, 0x0, + 0x0, 0x4, 0xff, 0x90, 0x0, 0x0, 0x4, 0xff, + 0x90, 0x0, 0x0, 0x4, 0xff, 0x90, 0x0, 0x0, + 0x4, 0xff, 0x90, 0x0, 0x0, 0x4, 0xff, 0x90, + 0x0, 0x0, 0x4, 0xff, 0x90, 0x0, 0x0, 0x4, + 0xff, 0x90, 0x0, 0x0, 0x4, 0xff, 0x90, 0x0, + 0x0, 0x4, 0xff, 0x90, 0x0, 0x0, 0x4, 0xff, + 0x90, 0x0, 0x0, 0x4, 0xff, 0x90, 0x0, 0x0, + 0x4, 0xff, 0x90, 0x0, 0x0, 0x4, 0xff, 0x90, + 0x0, 0x0, 0x4, 0xff, 0x90, 0x0, 0x0, 0x4, + 0xff, 0x90, 0x0, 0x0, 0x4, 0xff, 0x90, 0x0, + 0x0, 0x4, 0xff, 0x90, 0x0, 0x0, 0x4, 0xff, + 0x90, 0x0, + + /* U+03AB "Ϋ" */ + 0x0, 0x0, 0x2, 0xff, 0x90, 0xb, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0x90, 0xb, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0x90, 0xb, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xf7, 0xe, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xc0, 0x4, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x20, 0x0, 0xaf, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf6, 0x0, + 0x0, 0x1e, 0xff, 0x60, 0x0, 0x0, 0x6, 0xff, + 0xb0, 0x0, 0x0, 0x5, 0xff, 0xf1, 0x0, 0x0, + 0x1f, 0xff, 0x10, 0x0, 0x0, 0x0, 0xaf, 0xfb, + 0x0, 0x0, 0xbf, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0x50, 0x5, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xe0, 0xe, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf7, 0x8f, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf3, + 0x0, 0x0, 0x0, 0x0, + + /* U+03AC "ά" */ + 0x0, 0x0, 0x0, 0x7, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x22, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xae, 0xfe, 0xb4, 0x0, 0xaf, 0xf1, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0x70, 0xef, 0xc0, + 0x7, 0xff, 0xf8, 0x33, 0x7f, 0xf8, 0xff, 0x80, + 0x1f, 0xff, 0x40, 0x0, 0x3, 0xff, 0xff, 0x40, + 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x0, + 0xbf, 0xf3, 0x0, 0x0, 0x0, 0x2f, 0xfd, 0x0, + 0xdf, 0xf0, 0x0, 0x0, 0x0, 0xf, 0xf9, 0x0, + 0xef, 0xf0, 0x0, 0x0, 0x0, 0xe, 0xf6, 0x0, + 0xef, 0xf0, 0x0, 0x0, 0x0, 0xe, 0xf6, 0x0, + 0xdf, 0xf0, 0x0, 0x0, 0x0, 0xf, 0xf9, 0x0, + 0xaf, 0xf4, 0x0, 0x0, 0x0, 0x3f, 0xfc, 0x0, + 0x6f, 0xf9, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x0, + 0xf, 0xff, 0x30, 0x0, 0x4, 0xff, 0xff, 0x30, + 0x6, 0xff, 0xf7, 0x34, 0x9f, 0xf7, 0xff, 0x70, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0x80, 0xef, 0xb0, + 0x0, 0x3, 0xae, 0xfe, 0xb4, 0x0, 0x9f, 0xf1, + + /* U+03AD "έ" */ + 0x0, 0x0, 0x2, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x9, 0xff, 0x60, 0x0, 0x0, 0x0, 0x1f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x12, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x18, 0xdf, 0xfd, 0x92, 0x0, + 0x1, 0xdf, 0xff, 0xff, 0xff, 0x60, 0xa, 0xff, + 0xa5, 0x5a, 0xff, 0x90, 0xf, 0xfa, 0x0, 0x0, + 0x26, 0x0, 0x1f, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xc6, 0x42, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf9, + 0x0, 0x0, 0x3, 0xdf, 0xff, 0xf9, 0x0, 0x0, + 0x1e, 0xff, 0x72, 0x0, 0x0, 0x0, 0x6f, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xf8, 0x0, 0x0, 0x1b, 0x70, + 0x1f, 0xff, 0x94, 0x37, 0xef, 0xf6, 0x5, 0xff, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x3a, 0xef, 0xfd, + 0x82, 0x0, + + /* U+03AE "ή" */ + 0x0, 0x0, 0x0, 0x2, 0x21, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0x80, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xf6, 0x4, + 0xbe, 0xfd, 0x92, 0x0, 0xff, 0x69, 0xff, 0xff, + 0xff, 0xf5, 0xf, 0xfd, 0xfe, 0x75, 0x6b, 0xff, + 0xf1, 0xff, 0xfc, 0x0, 0x0, 0xa, 0xff, 0x6f, + 0xff, 0x20, 0x0, 0x0, 0x3f, 0xf9, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0xff, 0xaf, 0xfb, 0x0, 0x0, + 0x0, 0xf, 0xfa, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0xff, 0xaf, 0xfa, 0x0, 0x0, 0x0, 0xf, 0xfa, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0xff, 0xaf, 0xfa, + 0x0, 0x0, 0x0, 0xf, 0xfa, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0xff, 0xaf, 0xfa, 0x0, 0x0, 0x0, + 0xf, 0xfa, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xff, + 0xaf, 0xfa, 0x0, 0x0, 0x0, 0xf, 0xfa, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xa0, + + /* U+03AF "ί" */ + 0x0, 0x12, 0x21, 0x0, 0xcf, 0xf7, 0x4, 0xff, + 0xb0, 0xb, 0xfd, 0x0, 0x3f, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, + 0xf, 0xfa, 0x0, 0xf, 0xfa, 0x0, 0xf, 0xfa, + 0x0, 0xf, 0xfa, 0x0, 0xf, 0xfa, 0x0, 0xf, + 0xfa, 0x0, 0xf, 0xfa, 0x0, 0xf, 0xfa, 0x0, + 0xf, 0xfa, 0x0, 0xf, 0xfa, 0x0, 0xf, 0xfa, + 0x0, 0xf, 0xfa, 0x0, 0xf, 0xfa, 0x0, 0xf, + 0xfa, 0x0, 0xf, 0xfa, 0x0, + + /* U+03B0 "ΰ" */ + 0x0, 0x0, 0x0, 0x68, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xf5, 0x0, 0x0, 0x1f, 0xf7, 0x9, + 0xfa, 0xf, 0xf8, 0x1, 0xff, 0x71, 0xfe, 0x10, + 0xff, 0x80, 0x1d, 0xd5, 0x5d, 0x40, 0xd, 0xd7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, + 0x0, 0x0, 0x2f, 0xf7, 0xff, 0xa0, 0x0, 0x0, + 0x2, 0xff, 0x7f, 0xfa, 0x0, 0x0, 0x0, 0x2f, + 0xf7, 0xff, 0xa0, 0x0, 0x0, 0x2, 0xff, 0x7f, + 0xfa, 0x0, 0x0, 0x0, 0x2f, 0xf7, 0xff, 0xa0, + 0x0, 0x0, 0x2, 0xff, 0x7f, 0xfa, 0x0, 0x0, + 0x0, 0x2f, 0xf7, 0xff, 0xa0, 0x0, 0x0, 0x2, + 0xff, 0x7f, 0xfa, 0x0, 0x0, 0x0, 0x2f, 0xf7, + 0xff, 0xa0, 0x0, 0x0, 0x3, 0xff, 0x6e, 0xfb, + 0x0, 0x0, 0x0, 0x4f, 0xf5, 0xcf, 0xf0, 0x0, + 0x0, 0x8, 0xff, 0x27, 0xff, 0x80, 0x0, 0x2, + 0xff, 0xd0, 0xe, 0xff, 0xa4, 0x37, 0xef, 0xf5, + 0x0, 0x2e, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x7, 0xce, 0xfe, 0xa3, 0x0, 0x0, + + /* U+03B1 "α" */ + 0x0, 0x3, 0xae, 0xfe, 0xb4, 0x0, 0xaf, 0xf1, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0x70, 0xef, 0xc0, + 0x7, 0xff, 0xf8, 0x33, 0x7f, 0xf8, 0xff, 0x80, + 0x1f, 0xff, 0x40, 0x0, 0x3, 0xff, 0xff, 0x40, + 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x0, + 0xbf, 0xf3, 0x0, 0x0, 0x0, 0x2f, 0xfd, 0x0, + 0xdf, 0xf0, 0x0, 0x0, 0x0, 0xf, 0xf9, 0x0, + 0xef, 0xf0, 0x0, 0x0, 0x0, 0xe, 0xf6, 0x0, + 0xef, 0xf0, 0x0, 0x0, 0x0, 0xe, 0xf6, 0x0, + 0xdf, 0xf0, 0x0, 0x0, 0x0, 0xf, 0xf9, 0x0, + 0xaf, 0xf4, 0x0, 0x0, 0x0, 0x3f, 0xfc, 0x0, + 0x6f, 0xf9, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x0, + 0xf, 0xff, 0x30, 0x0, 0x4, 0xff, 0xff, 0x30, + 0x6, 0xff, 0xf7, 0x34, 0x9f, 0xf7, 0xff, 0x70, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0x80, 0xef, 0xb0, + 0x0, 0x3, 0xae, 0xfe, 0xb4, 0x0, 0x9f, 0xf1, + + /* U+03B2 "β" */ + 0x0, 0x4, 0xad, 0xfe, 0xc6, 0x0, 0x0, 0x1, + 0xaf, 0xff, 0xff, 0xff, 0xc1, 0x0, 0xb, 0xff, + 0xb5, 0x35, 0xcf, 0xfb, 0x0, 0x5f, 0xf8, 0x0, + 0x0, 0x9, 0xff, 0x30, 0xaf, 0xe0, 0x0, 0x0, + 0x0, 0xff, 0x80, 0xdf, 0xb0, 0x0, 0x0, 0x0, + 0xdf, 0x90, 0xef, 0xb0, 0x0, 0x0, 0x0, 0xff, + 0x70, 0xff, 0xa0, 0x0, 0x0, 0x7, 0xff, 0x10, + 0xff, 0xa0, 0x0, 0x3, 0x9f, 0xf4, 0x0, 0xff, + 0xa0, 0xf, 0xff, 0xf9, 0x20, 0x0, 0xff, 0xa0, + 0xf, 0xff, 0xfe, 0x92, 0x0, 0xff, 0xa0, 0x0, + 0x13, 0x7f, 0xff, 0x40, 0xff, 0xa0, 0x0, 0x0, + 0x2, 0xef, 0xe1, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x6f, 0xf8, 0xff, 0xb0, 0x0, 0x0, 0x0, 0xf, + 0xfc, 0xff, 0xc0, 0x0, 0x0, 0x0, 0xe, 0xfd, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0xe, 0xfc, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x2f, 0xf9, 0xff, 0xfd, + 0x10, 0x0, 0x0, 0xbf, 0xf3, 0xff, 0xff, 0xe5, + 0x10, 0x2a, 0xff, 0xa0, 0xff, 0xa8, 0xff, 0xff, + 0xff, 0xfb, 0x0, 0xff, 0xa0, 0x4a, 0xef, 0xeb, + 0x50, 0x0, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+03B3 "γ" */ + 0x7f, 0xf4, 0x0, 0x0, 0x0, 0x3, 0xff, 0x71, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x9f, 0xf1, 0xb, + 0xff, 0x0, 0x0, 0x0, 0xe, 0xfb, 0x0, 0x5f, + 0xf5, 0x0, 0x0, 0x4, 0xff, 0x50, 0x0, 0xff, + 0xb0, 0x0, 0x0, 0xaf, 0xf0, 0x0, 0xa, 0xff, + 0x10, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x4f, 0xf6, + 0x0, 0x5, 0xff, 0x40, 0x0, 0x0, 0xef, 0xb0, + 0x0, 0xbf, 0xe0, 0x0, 0x0, 0x8, 0xff, 0x10, + 0x1f, 0xf8, 0x0, 0x0, 0x0, 0x3f, 0xf6, 0x7, + 0xff, 0x20, 0x0, 0x0, 0x0, 0xdf, 0xc0, 0xcf, + 0xc0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x4f, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xfe, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xfd, 0x0, 0x0, 0x0, + + /* U+03B4 "δ" */ + 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, + 0xbf, 0xf9, 0x22, 0x22, 0x22, 0x20, 0x0, 0x0, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfc, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3e, 0xfe, 0x40, 0x0, 0x0, 0x0, 0x2, 0x9e, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0x6, 0xff, 0xf6, 0x10, + 0x29, 0xff, 0xc0, 0x1, 0xff, 0xf3, 0x0, 0x0, + 0x7, 0xff, 0x80, 0x6f, 0xf8, 0x0, 0x0, 0x0, + 0xc, 0xff, 0x1b, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x6f, 0xf5, 0xdf, 0xe0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0x8e, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xf9, 0xef, 0xc0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0x9c, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf8, + 0x9f, 0xf2, 0x0, 0x0, 0x0, 0x6, 0xff, 0x54, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0xcf, 0xf1, 0xc, + 0xff, 0x60, 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x3f, + 0xff, 0xa4, 0x35, 0xcf, 0xfd, 0x0, 0x0, 0x4e, + 0xff, 0xff, 0xff, 0xfc, 0x10, 0x0, 0x0, 0x18, + 0xce, 0xfe, 0xb5, 0x0, 0x0, + + /* U+03B5 "ε" */ + 0x0, 0x18, 0xdf, 0xfd, 0x92, 0x0, 0x1, 0xdf, + 0xff, 0xff, 0xff, 0x60, 0xa, 0xff, 0xa5, 0x5a, + 0xff, 0x90, 0xf, 0xfa, 0x0, 0x0, 0x26, 0x0, + 0x1f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xf, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xc6, 0x42, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf9, 0x0, 0x0, + 0x3, 0xdf, 0xff, 0xf9, 0x0, 0x0, 0x1e, 0xff, + 0x72, 0x0, 0x0, 0x0, 0x6f, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xf8, 0x0, 0x0, 0x1b, 0x70, 0x1f, 0xff, + 0x94, 0x37, 0xef, 0xf6, 0x5, 0xff, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x3a, 0xef, 0xfd, 0x82, 0x0, + + /* U+03B6 "ζ" */ + 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0x0, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0x0, 0x12, 0x22, 0x24, + 0xef, 0xc2, 0x0, 0x0, 0x0, 0x4e, 0xf9, 0x0, + 0x0, 0x0, 0x4, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x4f, 0xf8, 0x0, 0x0, 0x0, 0x2, 0xef, 0xa0, + 0x0, 0x0, 0x0, 0xc, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xf3, 0x0, 0x0, 0x0, 0x2, 0xff, + 0x90, 0x0, 0x0, 0x0, 0xa, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x1f, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfd, 0x30, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xca, 0x83, 0x0, + 0x5, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x4b, + 0xef, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x1, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xe, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf6, 0x0, 0x0, + 0x0, 0x28, 0xef, 0xe0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x30, 0x0, 0x0, 0x0, 0xdd, 0x91, 0x0, + + /* U+03B7 "η" */ + 0xff, 0x60, 0x4b, 0xef, 0xd9, 0x20, 0xf, 0xf6, + 0x9f, 0xff, 0xff, 0xff, 0x50, 0xff, 0xdf, 0xe7, + 0x56, 0xbf, 0xff, 0x1f, 0xff, 0xc0, 0x0, 0x0, + 0xaf, 0xf6, 0xff, 0xf2, 0x0, 0x0, 0x3, 0xff, + 0x9f, 0xfd, 0x0, 0x0, 0x0, 0xf, 0xfa, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0xff, 0xaf, 0xfa, 0x0, + 0x0, 0x0, 0xf, 0xfa, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0xff, 0xaf, 0xfa, 0x0, 0x0, 0x0, 0xf, + 0xfa, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xff, 0xaf, + 0xfa, 0x0, 0x0, 0x0, 0xf, 0xfa, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0xff, 0xaf, 0xfa, 0x0, 0x0, + 0x0, 0xf, 0xfa, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0xff, 0xaf, 0xfa, 0x0, 0x0, 0x0, 0xf, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xfa, + + /* U+03B8 "θ" */ + 0x0, 0x0, 0x6b, 0xef, 0xea, 0x30, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0xbf, 0xfb, 0x43, 0x6e, 0xff, 0x60, 0x0, 0x4f, + 0xfa, 0x0, 0x0, 0x1d, 0xfe, 0x0, 0xb, 0xff, + 0x10, 0x0, 0x0, 0x5f, 0xf6, 0x0, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0xef, 0xb0, 0x4f, 0xf6, 0x0, + 0x0, 0x0, 0xb, 0xff, 0x6, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x8f, 0xf1, 0x8f, 0xf2, 0x0, 0x0, + 0x0, 0x7, 0xff, 0x39, 0xff, 0x32, 0x22, 0x22, + 0x22, 0x7f, 0xf4, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf5, 0x9f, 0xf1, 0x0, 0x0, 0x0, 0x6, + 0xff, 0x48, 0xff, 0x20, 0x0, 0x0, 0x0, 0x7f, + 0xf3, 0x6f, 0xf4, 0x0, 0x0, 0x0, 0x9, 0xff, + 0x14, 0xff, 0x60, 0x0, 0x0, 0x0, 0xbf, 0xf0, + 0xf, 0xfa, 0x0, 0x0, 0x0, 0xf, 0xfb, 0x0, + 0xbf, 0xf1, 0x0, 0x0, 0x5, 0xff, 0x60, 0x4, + 0xff, 0xa0, 0x0, 0x1, 0xef, 0xe0, 0x0, 0xb, + 0xff, 0xb5, 0x36, 0xef, 0xf6, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x6, + 0xbe, 0xfe, 0xa3, 0x0, 0x0, + + /* U+03B9 "ι" */ + 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, + 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xff, + 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, + + /* U+03BA "κ" */ + 0xf, 0xf9, 0x0, 0x0, 0x9, 0xff, 0xc1, 0xf, + 0xf9, 0x0, 0x0, 0x9f, 0xfc, 0x0, 0xf, 0xf9, + 0x0, 0x9, 0xff, 0xb0, 0x0, 0xf, 0xf9, 0x0, + 0x9f, 0xfb, 0x0, 0x0, 0xf, 0xf9, 0x9, 0xff, + 0xa0, 0x0, 0x0, 0xf, 0xf9, 0xaf, 0xf9, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xbf, 0xfd, 0x10, 0x0, 0x0, 0xf, + 0xfa, 0x9, 0xff, 0xb0, 0x0, 0x0, 0xf, 0xf9, + 0x0, 0xcf, 0xf8, 0x0, 0x0, 0xf, 0xf9, 0x0, + 0x1e, 0xff, 0x50, 0x0, 0xf, 0xf9, 0x0, 0x3, + 0xff, 0xf3, 0x0, 0xf, 0xf9, 0x0, 0x0, 0x6f, + 0xfe, 0x10, 0xf, 0xf9, 0x0, 0x0, 0x9, 0xff, + 0xc0, 0xf, 0xf9, 0x0, 0x0, 0x0, 0xcf, 0xf9, + + /* U+03BB "λ" */ + 0x0, 0x0, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, 0xff, + 0x60, 0x0, 0x0, 0x0, 0xc, 0xff, 0x2f, 0xfc, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xa0, 0xbf, 0xf2, + 0x0, 0x0, 0x0, 0x8f, 0xf4, 0x5, 0xff, 0x80, + 0x0, 0x0, 0xd, 0xfe, 0x0, 0xe, 0xfe, 0x0, + 0x0, 0x3, 0xff, 0x80, 0x0, 0x9f, 0xf4, 0x0, + 0x0, 0x9f, 0xf2, 0x0, 0x3, 0xff, 0x90, 0x0, + 0xf, 0xfc, 0x0, 0x0, 0xd, 0xff, 0x0, 0x5, + 0xff, 0x70, 0x0, 0x0, 0x7f, 0xf5, 0x0, 0xbf, + 0xf1, 0x0, 0x0, 0x1, 0xff, 0xb0, 0x1f, 0xfb, + 0x0, 0x0, 0x0, 0xb, 0xff, 0x17, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x5f, 0xf7, + + /* U+03BC "μ" */ + 0xff, 0xa0, 0x0, 0x0, 0x0, 0xff, 0xaf, 0xfa, + 0x0, 0x0, 0x0, 0xf, 0xfa, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0xff, 0xaf, 0xfa, 0x0, 0x0, 0x0, + 0xf, 0xfa, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xff, + 0xaf, 0xfa, 0x0, 0x0, 0x0, 0xf, 0xfa, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0xff, 0xaf, 0xfa, 0x0, + 0x0, 0x0, 0xf, 0xfa, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0xff, 0xaf, 0xfb, 0x0, 0x0, 0x0, 0xf, + 0xfa, 0xff, 0xd0, 0x0, 0x0, 0x2, 0xff, 0xaf, + 0xff, 0x20, 0x0, 0x0, 0x7f, 0xfa, 0xff, 0xfc, + 0x0, 0x0, 0x3f, 0xff, 0xaf, 0xff, 0xfe, 0x87, + 0xaf, 0xff, 0xfa, 0xff, 0xce, 0xff, 0xff, 0xfb, + 0xbf, 0xaf, 0xfa, 0x19, 0xef, 0xd7, 0xb, 0xfa, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03BD "ν" */ + 0x7f, 0xf5, 0x0, 0x0, 0x0, 0x3, 0xff, 0x71, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x9f, 0xf1, 0xb, + 0xff, 0x10, 0x0, 0x0, 0xe, 0xfb, 0x0, 0x5f, + 0xf6, 0x0, 0x0, 0x4, 0xff, 0x50, 0x0, 0xef, + 0xb0, 0x0, 0x0, 0xaf, 0xf0, 0x0, 0x9, 0xff, + 0x10, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x3f, 0xf6, + 0x0, 0x5, 0xff, 0x40, 0x0, 0x0, 0xdf, 0xc0, + 0x0, 0xbf, 0xe0, 0x0, 0x0, 0x7, 0xff, 0x20, + 0x1f, 0xf8, 0x0, 0x0, 0x0, 0x1f, 0xf7, 0x6, + 0xff, 0x20, 0x0, 0x0, 0x0, 0xbf, 0xc0, 0xcf, + 0xc0, 0x0, 0x0, 0x0, 0x5, 0xff, 0x3f, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xfc, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xfe, 0x0, 0x0, 0x0, + + /* U+03BE "ξ" */ + 0x0, 0x1, 0x8c, 0xef, 0xff, 0x50, 0x0, 0x5f, + 0xff, 0xff, 0xff, 0x50, 0x3, 0xff, 0xe8, 0x43, + 0x33, 0x0, 0xb, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0xd, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xa, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xb4, 0x10, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x1, 0x8f, 0xff, 0xff, 0x20, 0x0, 0x7, + 0xff, 0xe9, 0x54, 0x0, 0x0, 0x8f, 0xf9, 0x0, + 0x0, 0x0, 0x6, 0xff, 0x80, 0x0, 0x0, 0x0, + 0xf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xa2, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xeb, 0x94, 0x0, + 0x0, 0x3c, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x37, 0xad, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0xb, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xfb, 0x0, 0x0, + 0x0, 0x39, 0xef, 0xf3, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x60, 0x0, 0x0, 0x0, 0xdd, 0x92, 0x0, + + /* U+03BF "ο" */ + 0x0, 0x0, 0x7c, 0xef, 0xeb, 0x50, 0x0, 0x0, + 0x4, 0xef, 0xff, 0xff, 0xff, 0xc1, 0x0, 0x4, + 0xff, 0xf9, 0x43, 0x5c, 0xff, 0xd0, 0x0, 0xef, + 0xf4, 0x0, 0x0, 0x9, 0xff, 0x90, 0x6f, 0xf8, + 0x0, 0x0, 0x0, 0xd, 0xff, 0x1a, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x6f, 0xf5, 0xdf, 0xe0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0x8e, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xf9, 0xef, 0xc0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0x9d, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xf8, 0xaf, 0xf1, 0x0, 0x0, 0x0, + 0x6, 0xff, 0x56, 0xff, 0x80, 0x0, 0x0, 0x0, + 0xdf, 0xf1, 0xe, 0xff, 0x40, 0x0, 0x0, 0x8f, + 0xf9, 0x0, 0x4f, 0xff, 0x94, 0x35, 0xcf, 0xfe, + 0x10, 0x0, 0x4e, 0xff, 0xff, 0xff, 0xfc, 0x20, + 0x0, 0x0, 0x17, 0xce, 0xfe, 0xb5, 0x0, 0x0, + + /* U+03C0 "π" */ + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf0, 0x2, 0x22, 0x5f, + 0xf7, 0x22, 0x22, 0x23, 0xff, 0x92, 0x22, 0x0, + 0x0, 0x3, 0xff, 0x60, 0x0, 0x0, 0x2f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf6, 0x0, 0x0, + 0x2, 0xff, 0x80, 0x0, 0x0, 0x0, 0x3, 0xff, + 0x60, 0x0, 0x0, 0x2f, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xf6, 0x0, 0x0, 0x2, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x3, 0xff, 0x60, 0x0, 0x0, + 0x2f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf6, + 0x0, 0x0, 0x2, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x3, 0xff, 0x60, 0x0, 0x0, 0x2f, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xf6, 0x0, 0x0, 0x2, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x3, 0xff, 0x60, + 0x0, 0x0, 0x2f, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xf6, 0x0, 0x0, 0x2, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x3, 0xff, 0x60, 0x0, 0x0, 0x2f, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf6, 0x0, + 0x0, 0x2, 0xff, 0x80, 0x0, 0x0, 0x0, 0x3, + 0xff, 0x60, 0x0, 0x0, 0x2f, 0xf8, 0x0, 0x0, + + /* U+03C1 "ρ" */ + 0x0, 0x0, 0x4a, 0xef, 0xec, 0x71, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xfe, 0x40, 0x0, + 0x0, 0x9f, 0xfd, 0x63, 0x48, 0xff, 0xf3, 0x0, + 0x2, 0xff, 0xd1, 0x0, 0x0, 0x3f, 0xfe, 0x0, + 0x8, 0xff, 0x30, 0x0, 0x0, 0x6, 0xff, 0x60, + 0xc, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xff, 0xb0, + 0xf, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xe0, + 0xf, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf0, + 0x1f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf0, + 0x1f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xe0, + 0x1f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xff, 0xb0, + 0x1f, 0xff, 0x30, 0x0, 0x0, 0x6, 0xff, 0x60, + 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x2e, 0xfe, 0x0, + 0x1f, 0xff, 0xfd, 0x63, 0x48, 0xff, 0xf4, 0x0, + 0x1f, 0xfb, 0xef, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x1f, 0xf9, 0x7, 0xcf, 0xfd, 0x92, 0x0, 0x0, + 0x1f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03C2 "ς" */ + 0x0, 0x0, 0x3, 0x8c, 0xef, 0xed, 0xa0, 0x0, + 0x1, 0xbf, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x2e, + 0xff, 0xb6, 0x43, 0x47, 0x60, 0x1, 0xef, 0xe4, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xfe, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf8, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfc, 0x72, + 0x0, 0x0, 0x0, 0x4, 0xcf, 0xff, 0xff, 0xb1, + 0x0, 0x0, 0x0, 0x2, 0x7b, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0x40, 0x0, 0x0, 0x8, + 0x78, 0xdf, 0xfd, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xe2, 0x0, 0x0, 0x0, 0x4e, 0xff, 0xc7, + 0x0, 0x0, + + /* U+03C3 "σ" */ + 0x0, 0x1, 0x7c, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xd0, 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x5, 0xff, 0xf9, 0x43, 0x5b, 0xff, 0xe3, + 0x22, 0x11, 0xff, 0xf3, 0x0, 0x0, 0x9, 0xff, + 0x90, 0x0, 0x7f, 0xf7, 0x0, 0x0, 0x0, 0xd, + 0xff, 0x10, 0xb, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xf5, 0x0, 0xef, 0xd0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0x70, 0xf, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xf8, 0x0, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0x80, 0xe, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xf7, 0x0, 0xbf, 0xf0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0x40, 0x7, 0xff, 0x60, + 0x0, 0x0, 0x0, 0xdf, 0xf0, 0x0, 0x1f, 0xff, + 0x30, 0x0, 0x0, 0x9f, 0xf8, 0x0, 0x0, 0x5f, + 0xff, 0x84, 0x35, 0xcf, 0xfd, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xfb, 0x10, 0x0, 0x0, + 0x0, 0x18, 0xcf, 0xfe, 0xa4, 0x0, 0x0, 0x0, + + /* U+03C4 "τ" */ + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xf2, 0x2, 0x22, 0x5f, 0xf7, + 0x22, 0x20, 0x0, 0x0, 0x3f, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf6, 0x0, 0x0, + + /* U+03C5 "υ" */ + 0xff, 0xa0, 0x0, 0x0, 0x2, 0xff, 0x7f, 0xfa, + 0x0, 0x0, 0x0, 0x2f, 0xf7, 0xff, 0xa0, 0x0, + 0x0, 0x2, 0xff, 0x7f, 0xfa, 0x0, 0x0, 0x0, + 0x2f, 0xf7, 0xff, 0xa0, 0x0, 0x0, 0x2, 0xff, + 0x7f, 0xfa, 0x0, 0x0, 0x0, 0x2f, 0xf7, 0xff, + 0xa0, 0x0, 0x0, 0x2, 0xff, 0x7f, 0xfa, 0x0, + 0x0, 0x0, 0x2f, 0xf7, 0xff, 0xa0, 0x0, 0x0, + 0x2, 0xff, 0x7f, 0xfa, 0x0, 0x0, 0x0, 0x3f, + 0xf6, 0xef, 0xb0, 0x0, 0x0, 0x4, 0xff, 0x5c, + 0xff, 0x0, 0x0, 0x0, 0x8f, 0xf2, 0x7f, 0xf8, + 0x0, 0x0, 0x2f, 0xfd, 0x0, 0xef, 0xfa, 0x43, + 0x7e, 0xff, 0x50, 0x2, 0xef, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x7c, 0xef, 0xea, 0x30, 0x0, + + /* U+03C6 "φ" */ + 0x0, 0x2, 0xae, 0x30, 0x3c, 0xfe, 0xc7, 0x10, + 0x0, 0x0, 0x6f, 0xff, 0x1, 0xff, 0xff, 0xff, + 0xd2, 0x0, 0x5, 0xff, 0xe6, 0x5, 0xff, 0xb3, + 0x6f, 0xfd, 0x0, 0xe, 0xfe, 0x10, 0x7, 0xff, + 0x30, 0x4, 0xff, 0x70, 0x6f, 0xf5, 0x0, 0x7, + 0xff, 0x20, 0x0, 0xbf, 0xd0, 0xbf, 0xf0, 0x0, + 0x7, 0xff, 0x20, 0x0, 0x7f, 0xf2, 0xdf, 0xd0, + 0x0, 0x7, 0xff, 0x20, 0x0, 0x6f, 0xf4, 0xef, + 0xc0, 0x0, 0x7, 0xff, 0x20, 0x0, 0x6f, 0xf6, + 0xdf, 0xd0, 0x0, 0x7, 0xff, 0x20, 0x0, 0x7f, + 0xf4, 0xbf, 0xf1, 0x0, 0x7, 0xff, 0x20, 0x0, + 0xaf, 0xf1, 0x7f, 0xf6, 0x0, 0x7, 0xff, 0x20, + 0x1, 0xff, 0xc0, 0x1f, 0xfe, 0x10, 0x7, 0xff, + 0x20, 0xa, 0xff, 0x40, 0x8, 0xff, 0xc1, 0x7, + 0xff, 0x20, 0x9f, 0xfa, 0x0, 0x0, 0xaf, 0xff, + 0x9a, 0xff, 0x9d, 0xff, 0xc0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x3a, 0xef, 0xff, 0xe8, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0x20, 0x0, 0x0, 0x0, + + /* U+03C7 "χ" */ + 0x1f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xef, 0xe0, + 0x8, 0xff, 0x40, 0x0, 0x0, 0x7, 0xff, 0x60, + 0x1, 0xff, 0xc0, 0x0, 0x0, 0xe, 0xfd, 0x0, + 0x0, 0x8f, 0xf4, 0x0, 0x0, 0x7f, 0xf5, 0x0, + 0x0, 0x1f, 0xfc, 0x0, 0x0, 0xef, 0xc0, 0x0, + 0x0, 0x8, 0xff, 0x30, 0x7, 0xff, 0x40, 0x0, + 0x0, 0x1, 0xff, 0xb0, 0xe, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xf3, 0x7f, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xfb, 0xef, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xf8, 0xcf, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xe1, 0x4f, 0xf6, 0x0, 0x0, + 0x0, 0x3, 0xff, 0x70, 0xc, 0xfe, 0x0, 0x0, + 0x0, 0xc, 0xfe, 0x0, 0x4, 0xff, 0x80, 0x0, + 0x0, 0x5f, 0xf7, 0x0, 0x0, 0xcf, 0xf1, 0x0, + 0x0, 0xdf, 0xe0, 0x0, 0x0, 0x4f, 0xf9, 0x0, + 0x6, 0xff, 0x70, 0x0, 0x0, 0xc, 0xff, 0x20, + 0xe, 0xfe, 0x0, 0x0, 0x0, 0x4, 0xff, 0xa0, + 0x7f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf3, + + /* U+03C8 "ψ" */ + 0x3f, 0xf6, 0x0, 0x0, 0xaf, 0xf0, 0x0, 0x0, + 0xff, 0x93, 0xff, 0x60, 0x0, 0xa, 0xff, 0x0, + 0x0, 0xf, 0xf9, 0x3f, 0xf6, 0x0, 0x0, 0xaf, + 0xf0, 0x0, 0x0, 0xff, 0x93, 0xff, 0x60, 0x0, + 0xa, 0xff, 0x0, 0x0, 0xf, 0xf9, 0x3f, 0xf6, + 0x0, 0x0, 0xaf, 0xf0, 0x0, 0x0, 0xff, 0x93, + 0xff, 0x60, 0x0, 0xa, 0xff, 0x0, 0x0, 0xf, + 0xf9, 0x3f, 0xf6, 0x0, 0x0, 0xaf, 0xf0, 0x0, + 0x0, 0xff, 0x93, 0xff, 0x60, 0x0, 0xa, 0xff, + 0x0, 0x0, 0xf, 0xf9, 0x3f, 0xf6, 0x0, 0x0, + 0xaf, 0xf0, 0x0, 0x0, 0xff, 0x82, 0xff, 0x70, + 0x0, 0xa, 0xff, 0x0, 0x0, 0x1f, 0xf8, 0x1f, + 0xf9, 0x0, 0x0, 0xaf, 0xf0, 0x0, 0x4, 0xff, + 0x60, 0xdf, 0xe0, 0x0, 0xa, 0xff, 0x0, 0x0, + 0x9f, 0xf3, 0x7, 0xff, 0xa0, 0x0, 0xaf, 0xf0, + 0x0, 0x5f, 0xfe, 0x0, 0xc, 0xff, 0xe7, 0x5b, + 0xff, 0x46, 0xbf, 0xff, 0x40, 0x0, 0x1b, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0x40, 0x0, 0x0, + 0x4, 0xad, 0xff, 0xff, 0xfe, 0xc7, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0x0, 0x0, 0x0, + 0x0, + + /* U+03C9 "ω" */ + 0x0, 0xaf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf1, 0x0, 0x2, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xf9, 0x0, 0x9, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0x0, 0xe, 0xfc, 0x0, 0x0, 0x0, 0x11, 0x0, + 0x0, 0x6, 0xff, 0x50, 0x3f, 0xf8, 0x0, 0x0, + 0x9, 0xff, 0x0, 0x0, 0x1, 0xff, 0xa0, 0x7f, + 0xf4, 0x0, 0x0, 0x9, 0xff, 0x0, 0x0, 0x0, + 0xdf, 0xe0, 0x9f, 0xf1, 0x0, 0x0, 0x9, 0xff, + 0x0, 0x0, 0x0, 0xaf, 0xf0, 0xaf, 0xf0, 0x0, + 0x0, 0x9, 0xff, 0x0, 0x0, 0x0, 0x9f, 0xf1, + 0xbf, 0xf0, 0x0, 0x0, 0x9, 0xff, 0x0, 0x0, + 0x0, 0x8f, 0xf2, 0xaf, 0xf1, 0x0, 0x0, 0xa, + 0xff, 0x0, 0x0, 0x0, 0x9f, 0xf1, 0x7f, 0xf3, + 0x0, 0x0, 0xb, 0xff, 0x20, 0x0, 0x0, 0xcf, + 0xe0, 0x4f, 0xf9, 0x0, 0x0, 0xe, 0xff, 0x50, + 0x0, 0x1, 0xff, 0xb0, 0xe, 0xfe, 0x10, 0x0, + 0x6f, 0xdf, 0xc0, 0x0, 0x9, 0xff, 0x50, 0x6, + 0xff, 0xd3, 0x27, 0xff, 0x2b, 0xfc, 0x32, 0x8f, + 0xfd, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf6, 0x1, + 0xef, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x5, 0xcf, + 0xeb, 0x40, 0x0, 0x19, 0xdf, 0xe8, 0x10, 0x0, + + /* U+03CA "ϊ" */ + 0xdf, 0xf0, 0x5, 0xff, 0x6d, 0xff, 0x0, 0x5f, + 0xf6, 0xdf, 0xf0, 0x5, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, + 0x0, 0xff, 0xa0, 0x0, 0x0, 0xf, 0xfa, 0x0, + 0x0, 0x0, 0xff, 0xa0, 0x0, 0x0, 0xf, 0xfa, + 0x0, 0x0, 0x0, 0xff, 0xa0, 0x0, 0x0, 0xf, + 0xfa, 0x0, 0x0, 0x0, 0xff, 0xa0, 0x0, 0x0, + 0xf, 0xfa, 0x0, 0x0, 0x0, 0xff, 0xa0, 0x0, + 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, 0xff, 0xa0, + 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, 0xff, + 0xa0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, + 0xff, 0xa0, 0x0, + + /* U+03CB "ϋ" */ + 0x0, 0xef, 0xd0, 0x7, 0xff, 0x50, 0x0, 0xe, + 0xfd, 0x0, 0x7f, 0xf5, 0x0, 0x0, 0xef, 0xd0, + 0x7, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xa0, 0x0, 0x0, 0x2, 0xff, 0x7f, 0xfa, 0x0, + 0x0, 0x0, 0x2f, 0xf7, 0xff, 0xa0, 0x0, 0x0, + 0x2, 0xff, 0x7f, 0xfa, 0x0, 0x0, 0x0, 0x2f, + 0xf7, 0xff, 0xa0, 0x0, 0x0, 0x2, 0xff, 0x7f, + 0xfa, 0x0, 0x0, 0x0, 0x2f, 0xf7, 0xff, 0xa0, + 0x0, 0x0, 0x2, 0xff, 0x7f, 0xfa, 0x0, 0x0, + 0x0, 0x2f, 0xf7, 0xff, 0xa0, 0x0, 0x0, 0x2, + 0xff, 0x7f, 0xfa, 0x0, 0x0, 0x0, 0x3f, 0xf6, + 0xef, 0xb0, 0x0, 0x0, 0x4, 0xff, 0x5c, 0xff, + 0x0, 0x0, 0x0, 0x8f, 0xf2, 0x7f, 0xf8, 0x0, + 0x0, 0x2f, 0xfd, 0x0, 0xef, 0xfa, 0x43, 0x7e, + 0xff, 0x50, 0x2, 0xef, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x7c, 0xef, 0xea, 0x30, 0x0, + + /* U+03CC "ό" */ + 0x0, 0x0, 0x0, 0xa, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xe2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x21, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xce, + 0xfe, 0xb5, 0x0, 0x0, 0x0, 0x4e, 0xff, 0xff, + 0xff, 0xfc, 0x10, 0x0, 0x4f, 0xff, 0x94, 0x35, + 0xcf, 0xfd, 0x0, 0xe, 0xff, 0x40, 0x0, 0x0, + 0x9f, 0xf9, 0x6, 0xff, 0x80, 0x0, 0x0, 0x0, + 0xdf, 0xf1, 0xaf, 0xf1, 0x0, 0x0, 0x0, 0x6, + 0xff, 0x5d, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xf8, 0xef, 0xc0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0x9e, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf9, + 0xdf, 0xe0, 0x0, 0x0, 0x0, 0x3, 0xff, 0x8a, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x6f, 0xf5, 0x6f, + 0xf8, 0x0, 0x0, 0x0, 0xd, 0xff, 0x10, 0xef, + 0xf4, 0x0, 0x0, 0x8, 0xff, 0x90, 0x4, 0xff, + 0xf9, 0x43, 0x5c, 0xff, 0xe1, 0x0, 0x4, 0xef, + 0xff, 0xff, 0xff, 0xc2, 0x0, 0x0, 0x1, 0x7c, + 0xef, 0xeb, 0x50, 0x0, 0x0, + + /* U+03CD "ύ" */ + 0x0, 0x0, 0x0, 0xdf, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xfd, 0x10, 0x0, 0x0, 0x0, 0x3, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x12, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, + 0x0, 0x0, 0x2f, 0xf7, 0xff, 0xa0, 0x0, 0x0, + 0x2, 0xff, 0x7f, 0xfa, 0x0, 0x0, 0x0, 0x2f, + 0xf7, 0xff, 0xa0, 0x0, 0x0, 0x2, 0xff, 0x7f, + 0xfa, 0x0, 0x0, 0x0, 0x2f, 0xf7, 0xff, 0xa0, + 0x0, 0x0, 0x2, 0xff, 0x7f, 0xfa, 0x0, 0x0, + 0x0, 0x2f, 0xf7, 0xff, 0xa0, 0x0, 0x0, 0x2, + 0xff, 0x7f, 0xfa, 0x0, 0x0, 0x0, 0x2f, 0xf7, + 0xff, 0xa0, 0x0, 0x0, 0x3, 0xff, 0x6e, 0xfb, + 0x0, 0x0, 0x0, 0x4f, 0xf5, 0xcf, 0xf0, 0x0, + 0x0, 0x8, 0xff, 0x27, 0xff, 0x80, 0x0, 0x2, + 0xff, 0xd0, 0xe, 0xff, 0xa4, 0x37, 0xef, 0xf5, + 0x0, 0x2e, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x7, 0xce, 0xfe, 0xa3, 0x0, 0x0, + + /* U+03CE "ώ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf1, 0x0, + 0x2, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xf9, 0x0, 0x9, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0x0, 0xe, 0xfc, + 0x0, 0x0, 0x0, 0x11, 0x0, 0x0, 0x6, 0xff, + 0x50, 0x3f, 0xf8, 0x0, 0x0, 0x9, 0xff, 0x0, + 0x0, 0x1, 0xff, 0xa0, 0x7f, 0xf4, 0x0, 0x0, + 0x9, 0xff, 0x0, 0x0, 0x0, 0xdf, 0xe0, 0x9f, + 0xf1, 0x0, 0x0, 0x9, 0xff, 0x0, 0x0, 0x0, + 0xaf, 0xf0, 0xaf, 0xf0, 0x0, 0x0, 0x9, 0xff, + 0x0, 0x0, 0x0, 0x9f, 0xf1, 0xbf, 0xf0, 0x0, + 0x0, 0x9, 0xff, 0x0, 0x0, 0x0, 0x8f, 0xf2, + 0xaf, 0xf1, 0x0, 0x0, 0xa, 0xff, 0x0, 0x0, + 0x0, 0x9f, 0xf1, 0x7f, 0xf3, 0x0, 0x0, 0xb, + 0xff, 0x20, 0x0, 0x0, 0xcf, 0xe0, 0x4f, 0xf9, + 0x0, 0x0, 0xe, 0xff, 0x50, 0x0, 0x1, 0xff, + 0xb0, 0xe, 0xfe, 0x10, 0x0, 0x6f, 0xdf, 0xc0, + 0x0, 0x9, 0xff, 0x50, 0x6, 0xff, 0xd3, 0x27, + 0xff, 0x2b, 0xfc, 0x32, 0x8f, 0xfd, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xf6, 0x1, 0xef, 0xff, 0xff, + 0xe2, 0x0, 0x0, 0x5, 0xcf, 0xeb, 0x40, 0x0, + 0x19, 0xdf, 0xe8, 0x10, 0x0, + + /* U+03F4 "ϴ" */ + 0x0, 0x0, 0x2, 0xff, 0x70, 0x0, 0x4d, 0xd2, + 0xa, 0xfb, 0x2d, 0xd4, 0x5f, 0xf3, 0x2f, 0xe1, + 0x3f, 0xf5, 0x5f, 0xf3, 0x9f, 0x40, 0x3f, 0xf5 +}; + + +/*--------------------- + * GLYPH DESCRIPTION + *--------------------*/ + +static const lv_font_fmt_txt_glyph_dsc_t glyph_dsc[] = { + {.bitmap_index = 0, .adv_w = 0, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0} /* id = 0 reserved */, + {.bitmap_index = 0, .adv_w = 133, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 0, .adv_w = 134, .box_w = 4, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 44, .adv_w = 170, .box_w = 9, .box_h = 8, .ofs_x = 1, .ofs_y = 14}, + {.bitmap_index = 80, .adv_w = 267, .box_w = 17, .box_h = 22, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 267, .adv_w = 267, .box_w = 15, .box_h = 27, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 470, .adv_w = 427, .box_w = 24, .box_h = 22, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 734, .adv_w = 320, .box_w = 19, .box_h = 23, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 953, .adv_w = 91, .box_w = 4, .box_h = 8, .ofs_x = 1, .ofs_y = 14}, + {.bitmap_index = 969, .adv_w = 160, .box_w = 8, .box_h = 28, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 1081, .adv_w = 160, .box_w = 8, .box_h = 28, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 1193, .adv_w = 187, .box_w = 10, .box_h = 10, .ofs_x = 1, .ofs_y = 12}, + {.bitmap_index = 1243, .adv_w = 280, .box_w = 15, .box_h = 15, .ofs_x = 1, .ofs_y = 3}, + {.bitmap_index = 1356, .adv_w = 134, .box_w = 4, .box_h = 9, .ofs_x = 2, .ofs_y = -5}, + {.bitmap_index = 1374, .adv_w = 160, .box_w = 10, .box_h = 3, .ofs_x = 0, .ofs_y = 6}, + {.bitmap_index = 1389, .adv_w = 134, .box_w = 4, .box_h = 4, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 1397, .adv_w = 133, .box_w = 9, .box_h = 22, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1496, .adv_w = 267, .box_w = 15, .box_h = 22, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1661, .adv_w = 267, .box_w = 9, .box_h = 22, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 1760, .adv_w = 267, .box_w = 16, .box_h = 22, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1936, .adv_w = 267, .box_w = 15, .box_h = 22, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2101, .adv_w = 267, .box_w = 16, .box_h = 22, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2277, .adv_w = 267, .box_w = 15, .box_h = 22, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2442, .adv_w = 267, .box_w = 15, .box_h = 22, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2607, .adv_w = 267, .box_w = 15, .box_h = 22, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2772, .adv_w = 267, .box_w = 15, .box_h = 22, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2937, .adv_w = 267, .box_w = 15, .box_h = 22, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3102, .adv_w = 134, .box_w = 4, .box_h = 16, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 3134, .adv_w = 134, .box_w = 4, .box_h = 21, .ofs_x = 2, .ofs_y = -5}, + {.bitmap_index = 3176, .adv_w = 280, .box_w = 15, .box_h = 15, .ofs_x = 1, .ofs_y = 3}, + {.bitmap_index = 3289, .adv_w = 280, .box_w = 15, .box_h = 9, .ofs_x = 1, .ofs_y = 7}, + {.bitmap_index = 3357, .adv_w = 280, .box_w = 15, .box_h = 15, .ofs_x = 1, .ofs_y = 3}, + {.bitmap_index = 3470, .adv_w = 267, .box_w = 15, .box_h = 22, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3635, .adv_w = 487, .box_w = 29, .box_h = 28, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 4041, .adv_w = 320, .box_w = 22, .box_h = 22, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 4283, .adv_w = 320, .box_w = 17, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 4470, .adv_w = 347, .box_w = 20, .box_h = 22, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4690, .adv_w = 347, .box_w = 19, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 4899, .adv_w = 320, .box_w = 17, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 5086, .adv_w = 294, .box_w = 15, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 5251, .adv_w = 373, .box_w = 21, .box_h = 22, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 5482, .adv_w = 347, .box_w = 18, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 5680, .adv_w = 134, .box_w = 4, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 5724, .adv_w = 240, .box_w = 13, .box_h = 22, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5867, .adv_w = 320, .box_w = 18, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 6065, .adv_w = 267, .box_w = 14, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 6219, .adv_w = 400, .box_w = 21, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 6450, .adv_w = 347, .box_w = 18, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 6648, .adv_w = 373, .box_w = 21, .box_h = 22, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 6879, .adv_w = 320, .box_w = 17, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 7066, .adv_w = 373, .box_w = 22, .box_h = 24, .ofs_x = 1, .ofs_y = -2}, + {.bitmap_index = 7330, .adv_w = 347, .box_w = 20, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 7550, .adv_w = 320, .box_w = 18, .box_h = 22, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 7748, .adv_w = 294, .box_w = 18, .box_h = 22, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7946, .adv_w = 347, .box_w = 18, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 8144, .adv_w = 320, .box_w = 20, .box_h = 22, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 8364, .adv_w = 453, .box_w = 28, .box_h = 22, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 8672, .adv_w = 320, .box_w = 20, .box_h = 22, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 8892, .adv_w = 320, .box_w = 20, .box_h = 22, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 9112, .adv_w = 294, .box_w = 18, .box_h = 22, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 9310, .adv_w = 134, .box_w = 6, .box_h = 28, .ofs_x = 2, .ofs_y = -6}, + {.bitmap_index = 9394, .adv_w = 133, .box_w = 9, .box_h = 22, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 9493, .adv_w = 134, .box_w = 7, .box_h = 28, .ofs_x = 0, .ofs_y = -6}, + {.bitmap_index = 9591, .adv_w = 225, .box_w = 14, .box_h = 12, .ofs_x = 0, .ofs_y = 10}, + {.bitmap_index = 9675, .adv_w = 267, .box_w = 18, .box_h = 2, .ofs_x = -1, .ofs_y = -6}, + {.bitmap_index = 9693, .adv_w = 160, .box_w = 6, .box_h = 5, .ofs_x = 1, .ofs_y = 18}, + {.bitmap_index = 9708, .adv_w = 267, .box_w = 15, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 9828, .adv_w = 267, .box_w = 14, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 9982, .adv_w = 240, .box_w = 14, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 10094, .adv_w = 267, .box_w = 14, .box_h = 22, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 10248, .adv_w = 267, .box_w = 15, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 10368, .adv_w = 134, .box_w = 10, .box_h = 22, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 10478, .adv_w = 267, .box_w = 14, .box_h = 22, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 10632, .adv_w = 267, .box_w = 13, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 10775, .adv_w = 107, .box_w = 3, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 10808, .adv_w = 107, .box_w = 7, .box_h = 28, .ofs_x = -2, .ofs_y = -6}, + {.bitmap_index = 10906, .adv_w = 240, .box_w = 13, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 11049, .adv_w = 107, .box_w = 4, .box_h = 22, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 11093, .adv_w = 400, .box_w = 23, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 11277, .adv_w = 267, .box_w = 13, .box_h = 16, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 11381, .adv_w = 267, .box_w = 15, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 11501, .adv_w = 267, .box_w = 14, .box_h = 22, .ofs_x = 2, .ofs_y = -6}, + {.bitmap_index = 11655, .adv_w = 267, .box_w = 14, .box_h = 22, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 11809, .adv_w = 160, .box_w = 10, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 11889, .adv_w = 240, .box_w = 14, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 12001, .adv_w = 134, .box_w = 9, .box_h = 22, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 12100, .adv_w = 267, .box_w = 14, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 12212, .adv_w = 240, .box_w = 15, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 12332, .adv_w = 347, .box_w = 22, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 12508, .adv_w = 240, .box_w = 15, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 12628, .adv_w = 240, .box_w = 15, .box_h = 22, .ofs_x = 0, .ofs_y = -6}, + {.bitmap_index = 12793, .adv_w = 240, .box_w = 15, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 12913, .adv_w = 160, .box_w = 10, .box_h = 28, .ofs_x = 0, .ofs_y = -6}, + {.bitmap_index = 13053, .adv_w = 125, .box_w = 4, .box_h = 28, .ofs_x = 2, .ofs_y = -6}, + {.bitmap_index = 13109, .adv_w = 160, .box_w = 10, .box_h = 28, .ofs_x = 0, .ofs_y = -6}, + {.bitmap_index = 13249, .adv_w = 280, .box_w = 16, .box_h = 6, .ofs_x = 1, .ofs_y = 7}, + {.bitmap_index = 13297, .adv_w = 133, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 13297, .adv_w = 267, .box_w = 16, .box_h = 23, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 13481, .adv_w = 267, .box_w = 15, .box_h = 15, .ofs_x = 1, .ofs_y = 3}, + {.bitmap_index = 13594, .adv_w = 267, .box_w = 17, .box_h = 22, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 13781, .adv_w = 125, .box_w = 4, .box_h = 28, .ofs_x = 2, .ofs_y = -6}, + {.bitmap_index = 13837, .adv_w = 267, .box_w = 15, .box_h = 28, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 14047, .adv_w = 160, .box_w = 10, .box_h = 4, .ofs_x = 0, .ofs_y = 19}, + {.bitmap_index = 14067, .adv_w = 354, .box_w = 23, .box_h = 22, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 14320, .adv_w = 180, .box_w = 11, .box_h = 11, .ofs_x = 0, .ofs_y = 11}, + {.bitmap_index = 14381, .adv_w = 267, .box_w = 13, .box_h = 14, .ofs_x = 2, .ofs_y = 1}, + {.bitmap_index = 14472, .adv_w = 280, .box_w = 15, .box_h = 9, .ofs_x = 1, .ofs_y = 7}, + {.bitmap_index = 14540, .adv_w = 160, .box_w = 10, .box_h = 3, .ofs_x = 0, .ofs_y = 6}, + {.bitmap_index = 14555, .adv_w = 354, .box_w = 23, .box_h = 22, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 14808, .adv_w = 192, .box_w = 10, .box_h = 8, .ofs_x = 1, .ofs_y = 14}, + {.bitmap_index = 14848, .adv_w = 280, .box_w = 15, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 14983, .adv_w = 160, .box_w = 10, .box_h = 11, .ofs_x = 0, .ofs_y = 11}, + {.bitmap_index = 15038, .adv_w = 160, .box_w = 10, .box_h = 11, .ofs_x = 0, .ofs_y = 11}, + {.bitmap_index = 15093, .adv_w = 267, .box_w = 13, .box_h = 22, .ofs_x = 2, .ofs_y = -6}, + {.bitmap_index = 15236, .adv_w = 258, .box_w = 18, .box_h = 28, .ofs_x = -1, .ofs_y = -6}, + {.bitmap_index = 15488, .adv_w = 135, .box_w = 4, .box_h = 4, .ofs_x = 2, .ofs_y = 9}, + {.bitmap_index = 15496, .adv_w = 267, .box_w = 13, .box_h = 14, .ofs_x = 2, .ofs_y = 1}, + {.bitmap_index = 15587, .adv_w = 400, .box_w = 24, .box_h = 24, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 15875, .adv_w = 160, .box_w = 6, .box_h = 5, .ofs_x = 3, .ofs_y = 18}, + {.bitmap_index = 15890, .adv_w = 320, .box_w = 22, .box_h = 22, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 16132, .adv_w = 376, .box_w = 24, .box_h = 22, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 16396, .adv_w = 402, .box_w = 25, .box_h = 22, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 16671, .adv_w = 184, .box_w = 11, .box_h = 22, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 16792, .adv_w = 372, .box_w = 24, .box_h = 22, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 17056, .adv_w = 411, .box_w = 28, .box_h = 22, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 17364, .adv_w = 361, .box_w = 24, .box_h = 22, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 17628, .adv_w = 107, .box_w = 11, .box_h = 22, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 17749, .adv_w = 320, .box_w = 22, .box_h = 22, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 17991, .adv_w = 320, .box_w = 17, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 18178, .adv_w = 264, .box_w = 14, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 18332, .adv_w = 321, .box_w = 22, .box_h = 22, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 18574, .adv_w = 320, .box_w = 17, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 18761, .adv_w = 294, .box_w = 18, .box_h = 22, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 18959, .adv_w = 347, .box_w = 18, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 19157, .adv_w = 373, .box_w = 21, .box_h = 22, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 19388, .adv_w = 134, .box_w = 4, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 19432, .adv_w = 320, .box_w = 18, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 19630, .adv_w = 321, .box_w = 20, .box_h = 22, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 19850, .adv_w = 400, .box_w = 21, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 20081, .adv_w = 347, .box_w = 18, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 20279, .adv_w = 312, .box_w = 17, .box_h = 22, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 20466, .adv_w = 373, .box_w = 21, .box_h = 22, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 20697, .adv_w = 347, .box_w = 18, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 20895, .adv_w = 320, .box_w = 17, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 21082, .adv_w = 297, .box_w = 16, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 21258, .adv_w = 294, .box_w = 18, .box_h = 22, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 21456, .adv_w = 320, .box_w = 20, .box_h = 22, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 21676, .adv_w = 383, .box_w = 22, .box_h = 24, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 21940, .adv_w = 320, .box_w = 20, .box_h = 22, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 22160, .adv_w = 401, .box_w = 23, .box_h = 22, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 22413, .adv_w = 359, .box_w = 21, .box_h = 22, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 22644, .adv_w = 134, .box_w = 10, .box_h = 26, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 22774, .adv_w = 320, .box_w = 20, .box_h = 26, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 23034, .adv_w = 278, .box_w = 16, .box_h = 23, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 23218, .adv_w = 214, .box_w = 12, .box_h = 23, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 23356, .adv_w = 267, .box_w = 13, .box_h = 29, .ofs_x = 2, .ofs_y = -6}, + {.bitmap_index = 23545, .adv_w = 107, .box_w = 6, .box_h = 23, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 23614, .adv_w = 263, .box_w = 13, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 23764, .adv_w = 278, .box_w = 16, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 23892, .adv_w = 276, .box_w = 14, .box_h = 28, .ofs_x = 2, .ofs_y = -6}, + {.bitmap_index = 24088, .adv_w = 240, .box_w = 15, .box_h = 22, .ofs_x = 0, .ofs_y = -6}, + {.bitmap_index = 24253, .adv_w = 267, .box_w = 15, .box_h = 22, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 24418, .adv_w = 214, .box_w = 12, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 24514, .adv_w = 212, .box_w = 12, .box_h = 28, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 24682, .adv_w = 267, .box_w = 13, .box_h = 22, .ofs_x = 2, .ofs_y = -6}, + {.bitmap_index = 24825, .adv_w = 267, .box_w = 15, .box_h = 22, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 24990, .adv_w = 107, .box_w = 3, .box_h = 16, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 25014, .adv_w = 239, .box_w = 14, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 25126, .adv_w = 240, .box_w = 15, .box_h = 22, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 25291, .adv_w = 267, .box_w = 13, .box_h = 22, .ofs_x = 2, .ofs_y = -6}, + {.bitmap_index = 25434, .adv_w = 240, .box_w = 15, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 25554, .adv_w = 215, .box_w = 12, .box_h = 28, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 25722, .adv_w = 267, .box_w = 15, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 25842, .adv_w = 331, .box_w = 21, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 26010, .adv_w = 273, .box_w = 16, .box_h = 22, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 26186, .adv_w = 231, .box_w = 14, .box_h = 22, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 26340, .adv_w = 296, .box_w = 17, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 26476, .adv_w = 190, .box_w = 12, .box_h = 16, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 26572, .adv_w = 263, .box_w = 13, .box_h = 16, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 26676, .adv_w = 311, .box_w = 18, .box_h = 22, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 26874, .adv_w = 252, .box_w = 16, .box_h = 22, .ofs_x = 0, .ofs_y = -6}, + {.bitmap_index = 27050, .adv_w = 342, .box_w = 19, .box_h = 22, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 27259, .adv_w = 375, .box_w = 22, .box_h = 16, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 27435, .adv_w = 107, .box_w = 9, .box_h = 22, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 27534, .adv_w = 263, .box_w = 13, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 27677, .adv_w = 267, .box_w = 15, .box_h = 23, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 27850, .adv_w = 263, .box_w = 13, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 28000, .adv_w = 375, .box_w = 22, .box_h = 23, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 28253, .adv_w = 160, .box_w = 12, .box_h = 4, .ofs_x = -1, .ofs_y = 18} +}; + +/*--------------------- + * CHARACTER MAPPING + *--------------------*/ + +static const uint8_t glyph_id_ofs_list_1[] = { + 0, 0, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 0, + 13, 14, 15, 16, 0, 17, 18, 19, + 0, 0, 0, 20, 0, 21 +}; + +static const uint8_t glyph_id_ofs_list_2[] = { + 0, 0, 1, 0, 2, 3, 4, 0, + 5 +}; + +/*Collect the unicode lists and glyph_id offsets*/ +static const lv_font_fmt_txt_cmap_t cmaps[] = +{ + { + .range_start = 32, .range_length = 95, .glyph_id_start = 1, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 160, .range_length = 30, .glyph_id_start = 96, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_1, .list_length = 30, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 900, .range_length = 9, .glyph_id_start = 118, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_2, .list_length = 9, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 910, .range_length = 20, .glyph_id_start = 124, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 931, .range_length = 44, .glyph_id_start = 144, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 1012, .range_length = 1, .glyph_id_start = 188, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + } +}; + + + +/*-------------------- + * ALL CUSTOM DATA + *--------------------*/ + +#if LVGL_VERSION_MAJOR == 8 +/*Store all the custom data of the font*/ +static lv_font_fmt_txt_glyph_cache_t cache; +#endif + +#if LVGL_VERSION_MAJOR >= 8 +static const lv_font_fmt_txt_dsc_t font_dsc = { +#else +static lv_font_fmt_txt_dsc_t font_dsc = { +#endif + .glyph_bitmap = glyph_bitmap, + .glyph_dsc = glyph_dsc, + .cmaps = cmaps, + .kern_dsc = NULL, + .kern_scale = 0, + .cmap_num = 6, + .bpp = 4, + .kern_classes = 0, + .bitmap_format = 0, +#if LVGL_VERSION_MAJOR == 8 + .cache = &cache +#endif + +}; + +extern const lv_font_t lv_font_montserrat_30; + + +/*----------------- + * PUBLIC FONT + *----------------*/ + +/*Initialize a public general font descriptor*/ +#if LVGL_VERSION_MAJOR >= 8 +const lv_font_t lv_font_arial_30 = { +#else +lv_font_t lv_font_arial_30 = { +#endif + .get_glyph_dsc = lv_font_get_glyph_dsc_fmt_txt, /*Function pointer to get glyph's data*/ + .get_glyph_bitmap = lv_font_get_bitmap_fmt_txt, /*Function pointer to get glyph's bitmap*/ + .line_height = 32, /*The maximum line height required by the font*/ + .base_line = 6, /*Baseline measured from the bottom of the line*/ +#if !(LVGL_VERSION_MAJOR == 6 && LVGL_VERSION_MINOR == 0) + .subpx = LV_FONT_SUBPX_NONE, +#endif +#if LV_VERSION_CHECK(7, 4, 0) || LVGL_VERSION_MAJOR >= 8 + .underline_position = -3, + .underline_thickness = 2, +#endif + //.static_bitmap = 0, + .dsc = &font_dsc, /*The custom font data. Will be accessed by `get_glyph_bitmap/dsc` */ +#if LV_VERSION_CHECK(8, 2, 0) || LVGL_VERSION_MAJOR >= 9 + .fallback = &lv_font_montserrat_30, +#endif + .user_data = NULL, +}; + + + +#endif /*#if LV_FONT_ARIAL_30*/ diff --git a/src/fonts/lv_font_arial_32.c b/src/fonts/lv_font_arial_32.c new file mode 100644 index 0000000000..6b4fb1c1e0 --- /dev/null +++ b/src/fonts/lv_font_arial_32.c @@ -0,0 +1,4745 @@ +/******************************************************************************* + * Size: 32 px + * Bpp: 4 + * Opts: --bpp 4 --size 32 --no-compress --stride 1 --align 1 --font Arial Greek Regular.ttf --range 32-127,160-255,880-1023 --format lvgl -o lv_font_arial_32.c + ******************************************************************************/ + +#ifdef __has_include + #if __has_include("lvgl.h") + #ifndef LV_LVGL_H_INCLUDE_SIMPLE + #define LV_LVGL_H_INCLUDE_SIMPLE + #endif + #endif +#endif + +#ifdef LV_LVGL_H_INCLUDE_SIMPLE + #include "lvgl.h" +#else + #include "lvgl/lvgl.h" +#endif + + + +#ifndef LV_FONT_ARIAL_32 +#define LV_FONT_ARIAL_32 1 +#endif + +#if LV_FONT_ARIAL_32 + +/*----------------- + * BITMAPS + *----------------*/ + +/*Store the image of the glyphs*/ +static LV_ATTRIBUTE_LARGE_CONST const uint8_t glyph_bitmap[] = { + /* U+0020 " " */ + + /* U+0021 "!" */ + 0x4f, 0xff, 0x34, 0xff, 0xf3, 0x4f, 0xff, 0x34, + 0xff, 0xf3, 0x4f, 0xff, 0x34, 0xff, 0xf2, 0x3f, + 0xff, 0x12, 0xff, 0xf0, 0xf, 0xff, 0x0, 0xff, + 0xe0, 0xe, 0xfd, 0x0, 0xdf, 0xc0, 0xc, 0xfb, + 0x0, 0xbf, 0x90, 0xa, 0xf8, 0x0, 0x9f, 0x70, + 0x7, 0xf6, 0x0, 0x14, 0x10, 0x0, 0x0, 0x0, + 0x33, 0x30, 0x2f, 0xff, 0x12, 0xff, 0xf1, 0x2f, + 0xff, 0x10, + + /* U+0022 "\"" */ + 0x8f, 0xfb, 0x5, 0xff, 0xe8, 0xff, 0xb0, 0x5f, + 0xfe, 0x8f, 0xfb, 0x5, 0xff, 0xe8, 0xff, 0xa0, + 0x5f, 0xfd, 0x6f, 0xf9, 0x3, 0xff, 0xb3, 0xff, + 0x60, 0xf, 0xf9, 0xf, 0xf3, 0x0, 0xdf, 0x60, + 0xdf, 0x10, 0xa, 0xf3, 0x1, 0x10, 0x0, 0x12, + 0x0, + + /* U+0023 "#" */ + 0x0, 0x0, 0x0, 0xaf, 0xb0, 0x0, 0x5, 0xff, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0x70, 0x0, 0x9, + 0xfc, 0x0, 0x0, 0x0, 0x1, 0xff, 0x40, 0x0, + 0xd, 0xf8, 0x0, 0x0, 0x0, 0x5, 0xff, 0x0, + 0x0, 0xf, 0xf5, 0x0, 0x0, 0x0, 0x8, 0xfc, + 0x0, 0x0, 0x4f, 0xf1, 0x0, 0x0, 0x0, 0xc, + 0xf9, 0x0, 0x0, 0x7f, 0xd0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, + 0x35, 0x55, 0x9f, 0xf5, 0x55, 0x56, 0xff, 0x75, + 0x52, 0x0, 0x0, 0x9f, 0xc0, 0x0, 0x5, 0xff, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0x80, 0x0, 0x8, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0xff, 0x50, 0x0, + 0xb, 0xf9, 0x0, 0x0, 0x0, 0x3, 0xff, 0x20, + 0x0, 0xe, 0xf6, 0x0, 0x0, 0x0, 0x6, 0xff, + 0x0, 0x0, 0x2f, 0xf3, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, + 0x35, 0x5f, 0xf8, 0x55, 0x55, 0xdf, 0xb5, 0x55, + 0x52, 0x0, 0x3f, 0xf2, 0x0, 0x0, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x6f, 0xe0, 0x0, 0x2, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x9f, 0xb0, 0x0, 0x5, + 0xff, 0x0, 0x0, 0x0, 0x0, 0xdf, 0x80, 0x0, + 0x8, 0xfc, 0x0, 0x0, 0x0, 0x0, 0xff, 0x50, + 0x0, 0xc, 0xf9, 0x0, 0x0, 0x0, 0x3, 0xff, + 0x10, 0x0, 0xf, 0xf6, 0x0, 0x0, 0x0, + + /* U+0024 "$" */ + 0x0, 0x0, 0x0, 0x7, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x9e, 0xff, 0xff, 0xc6, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xc1, 0x0, + 0x2, 0xff, 0xfb, 0x5f, 0xc8, 0xff, 0xfb, 0x0, + 0xb, 0xff, 0x80, 0xf, 0xb0, 0x2f, 0xff, 0x30, + 0x1f, 0xfd, 0x0, 0xf, 0xb0, 0x8, 0xff, 0x90, + 0x4f, 0xf9, 0x0, 0xf, 0xb0, 0x3, 0xdb, 0x60, + 0x4f, 0xf9, 0x0, 0xf, 0xb0, 0x0, 0x0, 0x0, + 0x2f, 0xfd, 0x0, 0xf, 0xb0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0x70, 0xf, 0xb0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xfa, 0x3f, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xd6, 0x20, 0x0, 0x0, + 0x0, 0x5, 0xef, 0xff, 0xff, 0xfb, 0x30, 0x0, + 0x0, 0x0, 0x4, 0x9f, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xb6, 0xdf, 0xff, 0x40, + 0x0, 0x0, 0x0, 0xf, 0xb0, 0x9, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0xf, 0xb0, 0x0, 0xef, 0xf2, + 0x0, 0x30, 0x0, 0xf, 0xb0, 0x0, 0xaf, 0xf4, + 0xaf, 0xf2, 0x0, 0xf, 0xb0, 0x0, 0x8f, 0xf5, + 0x9f, 0xf7, 0x0, 0xf, 0xb0, 0x0, 0xbf, 0xf3, + 0x5f, 0xfd, 0x0, 0xf, 0xb0, 0x1, 0xff, 0xf0, + 0xe, 0xff, 0x90, 0xf, 0xb0, 0x1c, 0xff, 0x80, + 0x4, 0xff, 0xfc, 0x6f, 0xc8, 0xef, 0xfd, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xd1, 0x0, + 0x0, 0x1, 0x7c, 0xff, 0xfe, 0xc6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xb0, 0x0, 0x0, 0x0, + + /* U+0025 "%" */ + 0x0, 0x7, 0xdf, 0xeb, 0x30, 0x0, 0x0, 0x0, + 0x0, 0xef, 0x50, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x7, 0xfd, 0x0, + 0x0, 0x0, 0x6, 0xff, 0x60, 0x1a, 0xff, 0x10, + 0x0, 0x0, 0x1e, 0xf4, 0x0, 0x0, 0x0, 0xd, + 0xfb, 0x0, 0x1, 0xff, 0x70, 0x0, 0x0, 0x8f, + 0xb0, 0x0, 0x0, 0x0, 0xf, 0xf7, 0x0, 0x0, + 0xdf, 0xa0, 0x0, 0x1, 0xff, 0x30, 0x0, 0x0, + 0x0, 0xf, 0xf6, 0x0, 0x0, 0xcf, 0xb0, 0x0, + 0xa, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xf, 0xf7, + 0x0, 0x0, 0xdf, 0xa0, 0x0, 0x3f, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xfb, 0x0, 0x1, 0xff, + 0x70, 0x0, 0xbf, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0x61, 0x2b, 0xff, 0x10, 0x4, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xf4, 0x0, 0xc, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xce, 0xea, 0x20, 0x0, + 0x5f, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0x60, 0x0, + 0x8d, 0xfe, 0x91, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xfd, 0x0, 0xc, 0xff, 0xff, 0xfe, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xf4, + 0x0, 0x7f, 0xf4, 0x2, 0xdf, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xc0, 0x0, 0xef, 0x90, + 0x0, 0x4f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0x30, 0x2, 0xff, 0x50, 0x0, 0xf, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xfa, 0x0, 0x3, + 0xff, 0x30, 0x0, 0xf, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xf2, 0x0, 0x3, 0xff, 0x30, 0x0, + 0xe, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xbf, 0x90, + 0x0, 0x2, 0xff, 0x40, 0x0, 0xf, 0xf6, 0x0, + 0x0, 0x0, 0x4, 0xff, 0x10, 0x0, 0x0, 0xef, + 0x90, 0x0, 0x4f, 0xf2, 0x0, 0x0, 0x0, 0xc, + 0xf8, 0x0, 0x0, 0x0, 0x8f, 0xf4, 0x2, 0xdf, + 0xc0, 0x0, 0x0, 0x0, 0x5f, 0xe0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, + 0x0, 0xdf, 0x60, 0x0, 0x0, 0x0, 0x0, 0x8d, + 0xfe, 0x91, 0x0, + + /* U+0026 "&" */ + 0x0, 0x0, 0x1, 0x8d, 0xff, 0xc6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xfb, + 0x67, 0xef, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0x90, 0x0, 0x2f, 0xff, 0x10, 0x0, 0x0, + 0x0, 0xb, 0xff, 0x30, 0x0, 0xb, 0xff, 0x30, + 0x0, 0x0, 0x0, 0xa, 0xff, 0x40, 0x0, 0xb, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x6, 0xff, 0xb0, + 0x0, 0x1f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xf7, 0x1, 0xdf, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0x8e, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xd3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6e, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1c, + 0xff, 0xfd, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xdf, 0xfd, 0x21, 0xef, 0xfc, 0x0, 0xb, + 0x95, 0x0, 0xb, 0xff, 0xc0, 0x0, 0x3f, 0xff, + 0xa0, 0x4f, 0xfd, 0x0, 0x3f, 0xfe, 0x10, 0x0, + 0x5, 0xff, 0xf7, 0xaf, 0xf8, 0x0, 0x8f, 0xf9, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf2, 0x0, + 0x9f, 0xf7, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xa0, 0x0, 0x8f, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x30, 0x0, 0x3f, 0xff, 0x20, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xd1, 0x0, 0xc, 0xff, + 0xd2, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfc, 0x10, + 0x2, 0xff, 0xff, 0xa8, 0x9e, 0xff, 0xf9, 0x4f, + 0xff, 0xe3, 0x0, 0x3e, 0xff, 0xff, 0xff, 0xff, + 0x60, 0x5, 0xff, 0xf2, 0x0, 0x0, 0x6b, 0xef, + 0xec, 0x71, 0x0, 0x0, 0x3e, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0027 "'" */ + 0x8f, 0xfa, 0x8f, 0xfa, 0x8f, 0xfa, 0x8f, 0xfa, + 0x6f, 0xf8, 0x4f, 0xf5, 0x1f, 0xf3, 0xe, 0xf0, + 0x1, 0x10, + + /* U+0028 "(" */ + 0x0, 0x0, 0x0, 0xdf, 0x30, 0x0, 0x0, 0x9f, + 0x90, 0x0, 0x0, 0x4f, 0xf1, 0x0, 0x0, 0xd, + 0xf8, 0x0, 0x0, 0x6, 0xff, 0x10, 0x0, 0x0, + 0xef, 0xa0, 0x0, 0x0, 0x6f, 0xf4, 0x0, 0x0, + 0xc, 0xfe, 0x0, 0x0, 0x1, 0xff, 0xa0, 0x0, + 0x0, 0x6f, 0xf6, 0x0, 0x0, 0xa, 0xff, 0x20, + 0x0, 0x0, 0xdf, 0xf0, 0x0, 0x0, 0xf, 0xfe, + 0x0, 0x0, 0x0, 0xff, 0xd0, 0x0, 0x0, 0xf, + 0xfd, 0x0, 0x0, 0x0, 0xff, 0xd0, 0x0, 0x0, + 0xf, 0xfe, 0x0, 0x0, 0x0, 0xdf, 0xf0, 0x0, + 0x0, 0xa, 0xff, 0x30, 0x0, 0x0, 0x6f, 0xf6, + 0x0, 0x0, 0x2, 0xff, 0xa0, 0x0, 0x0, 0xc, + 0xfe, 0x0, 0x0, 0x0, 0x6f, 0xf4, 0x0, 0x0, + 0x0, 0xef, 0xa0, 0x0, 0x0, 0x7, 0xff, 0x10, + 0x0, 0x0, 0xd, 0xf8, 0x0, 0x0, 0x0, 0x4f, + 0xf1, 0x0, 0x0, 0x0, 0x9f, 0x90, 0x0, 0x0, + 0x0, 0xdf, 0x30, + + /* U+0029 ")" */ + 0x8f, 0x80, 0x0, 0x0, 0xe, 0xf4, 0x0, 0x0, + 0x6, 0xfd, 0x0, 0x0, 0x0, 0xdf, 0x80, 0x0, + 0x0, 0x6f, 0xf1, 0x0, 0x0, 0xf, 0xf9, 0x0, + 0x0, 0x9, 0xff, 0x10, 0x0, 0x4, 0xff, 0x60, + 0x0, 0x0, 0xff, 0xc0, 0x0, 0x0, 0xbf, 0xf0, + 0x0, 0x0, 0x8f, 0xf4, 0x0, 0x0, 0x6f, 0xf7, + 0x0, 0x0, 0x4f, 0xf9, 0x0, 0x0, 0x3f, 0xfa, + 0x0, 0x0, 0x2f, 0xfb, 0x0, 0x0, 0x3f, 0xfa, + 0x0, 0x0, 0x4f, 0xf9, 0x0, 0x0, 0x6f, 0xf7, + 0x0, 0x0, 0x8f, 0xf4, 0x0, 0x0, 0xcf, 0xf1, + 0x0, 0x0, 0xff, 0xc0, 0x0, 0x4, 0xff, 0x60, + 0x0, 0x9, 0xff, 0x10, 0x0, 0xf, 0xf8, 0x0, + 0x0, 0x6f, 0xf1, 0x0, 0x0, 0xdf, 0x80, 0x0, + 0x6, 0xfe, 0x0, 0x0, 0xe, 0xf4, 0x0, 0x0, + 0x8f, 0x80, 0x0, 0x0, + + /* U+002A "*" */ + 0x0, 0x0, 0xef, 0x40, 0x0, 0x0, 0x0, 0xd, + 0xf4, 0x0, 0x0, 0x25, 0x0, 0xcf, 0x20, 0x26, + 0x9, 0xfe, 0x8b, 0xf5, 0xcf, 0xf0, 0x9e, 0xff, + 0xff, 0xff, 0xfd, 0x30, 0x2, 0x9f, 0xfd, 0x52, + 0x0, 0x0, 0x2e, 0xfd, 0xf8, 0x0, 0x0, 0x1d, + 0xf9, 0x2f, 0xf6, 0x0, 0x6, 0xfe, 0x10, 0x8f, + 0xd0, 0x0, 0x4, 0x40, 0x0, 0x80, 0x0, + + /* U+002B "+" */ + 0x0, 0x0, 0x0, 0x2, 0x21, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x2a, 0xaa, 0xaa, 0xaf, 0xfe, 0xaa, 0xaa, 0xa9, + 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, + + /* U+002C "," */ + 0x3, 0x33, 0x3f, 0xff, 0x3f, 0xff, 0x3f, 0xff, + 0x0, 0xae, 0x0, 0xdc, 0x6, 0xf7, 0x2f, 0xc0, + 0x5, 0x0, + + /* U+002D "-" */ + 0xdd, 0xdd, 0xdd, 0xdd, 0x8f, 0xff, 0xff, 0xff, + 0xfa, 0xff, 0xff, 0xff, 0xff, 0xa0, + + /* U+002E "." */ + 0x3, 0x33, 0x2, 0xff, 0xf0, 0x2f, 0xff, 0x2, + 0xff, 0xf0, + + /* U+002F "/" */ + 0x0, 0x0, 0x0, 0x8f, 0xb0, 0x0, 0x0, 0xc, + 0xf7, 0x0, 0x0, 0x1, 0xff, 0x20, 0x0, 0x0, + 0x5f, 0xe0, 0x0, 0x0, 0xa, 0xf9, 0x0, 0x0, + 0x0, 0xef, 0x40, 0x0, 0x0, 0x3f, 0xf0, 0x0, + 0x0, 0x8, 0xfb, 0x0, 0x0, 0x0, 0xdf, 0x70, + 0x0, 0x0, 0x1f, 0xf2, 0x0, 0x0, 0x6, 0xfd, + 0x0, 0x0, 0x0, 0xaf, 0x90, 0x0, 0x0, 0xf, + 0xf4, 0x0, 0x0, 0x4, 0xff, 0x0, 0x0, 0x0, + 0x8f, 0xb0, 0x0, 0x0, 0xd, 0xf6, 0x0, 0x0, + 0x1, 0xff, 0x20, 0x0, 0x0, 0x6f, 0xd0, 0x0, + 0x0, 0xb, 0xf8, 0x0, 0x0, 0x0, 0xff, 0x40, + 0x0, 0x0, 0x4f, 0xf0, 0x0, 0x0, 0x9, 0xfb, + 0x0, 0x0, 0x0, 0xdf, 0x60, 0x0, 0x0, 0x0, + + /* U+0030 "0" */ + 0x0, 0x0, 0x39, 0xdf, 0xec, 0x81, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xfe, 0x40, 0x0, + 0x0, 0x6f, 0xff, 0x96, 0x6b, 0xff, 0xf2, 0x0, + 0x1, 0xff, 0xf3, 0x0, 0x0, 0x7f, 0xfc, 0x0, + 0x8, 0xff, 0x60, 0x0, 0x0, 0xb, 0xff, 0x30, + 0xd, 0xff, 0x0, 0x0, 0x0, 0x4, 0xff, 0x90, + 0x2f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xff, 0xd0, + 0x4f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf0, + 0x7f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf2, + 0x8f, 0xf5, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf3, + 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, + 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf5, + 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, + 0x8f, 0xf5, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf3, + 0x7f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf2, + 0x4f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf0, + 0x2f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xff, 0xd0, + 0xd, 0xff, 0x0, 0x0, 0x0, 0x4, 0xff, 0x90, + 0x8, 0xff, 0x70, 0x0, 0x0, 0xb, 0xff, 0x40, + 0x1, 0xff, 0xf3, 0x0, 0x0, 0x7f, 0xfc, 0x0, + 0x0, 0x6f, 0xff, 0x95, 0x6b, 0xff, 0xf2, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xfe, 0x40, 0x0, + 0x0, 0x0, 0x39, 0xdf, 0xfd, 0x81, 0x0, 0x0, + + /* U+0031 "1" */ + 0x0, 0x0, 0x0, 0x2f, 0xf0, 0x0, 0x0, 0xc, + 0xff, 0x0, 0x0, 0xb, 0xff, 0xf0, 0x0, 0x1b, + 0xff, 0xff, 0x0, 0x5e, 0xff, 0xff, 0xf2, 0xcf, + 0xff, 0xad, 0xff, 0x7f, 0xff, 0x60, 0xdf, 0xf7, + 0xf9, 0x10, 0xd, 0xff, 0x21, 0x0, 0x0, 0xdf, + 0xf0, 0x0, 0x0, 0xd, 0xff, 0x0, 0x0, 0x0, + 0xdf, 0xf0, 0x0, 0x0, 0xd, 0xff, 0x0, 0x0, + 0x0, 0xdf, 0xf0, 0x0, 0x0, 0xd, 0xff, 0x0, + 0x0, 0x0, 0xdf, 0xf0, 0x0, 0x0, 0xd, 0xff, + 0x0, 0x0, 0x0, 0xdf, 0xf0, 0x0, 0x0, 0xd, + 0xff, 0x0, 0x0, 0x0, 0xdf, 0xf0, 0x0, 0x0, + 0xd, 0xff, 0x0, 0x0, 0x0, 0xdf, 0xf0, 0x0, + 0x0, 0xd, 0xff, 0x0, 0x0, 0x0, 0xdf, 0xf0, + + /* U+0032 "2" */ + 0x0, 0x0, 0x5a, 0xef, 0xfd, 0xa4, 0x0, 0x0, + 0x0, 0x1c, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x1, 0xdf, 0xfe, 0x86, 0x69, 0xff, 0xfb, 0x0, + 0x9, 0xff, 0xb0, 0x0, 0x0, 0x2d, 0xff, 0x60, + 0xf, 0xfe, 0x0, 0x0, 0x0, 0x3, 0xff, 0xc0, + 0x4f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf0, + 0x4b, 0xd6, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfe, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x1c, 0xff, 0xe2, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xef, 0xfd, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xb1, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + + /* U+0033 "3" */ + 0x0, 0x0, 0x6b, 0xef, 0xec, 0x71, 0x0, 0x0, + 0x0, 0x2d, 0xff, 0xff, 0xff, 0xfe, 0x40, 0x0, + 0x1, 0xef, 0xfd, 0x75, 0x7c, 0xff, 0xf3, 0x0, + 0x9, 0xff, 0xa0, 0x0, 0x0, 0x7f, 0xfd, 0x0, + 0xf, 0xff, 0x10, 0x0, 0x0, 0xc, 0xff, 0x20, + 0x2b, 0xea, 0x0, 0x0, 0x0, 0xa, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x4a, 0xff, 0xe2, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfb, 0x20, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0x91, 0x0, + 0x0, 0x0, 0x0, 0x53, 0x36, 0xef, 0xfd, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1c, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf6, + 0x5b, 0xd5, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf5, + 0x6f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf2, + 0x1f, 0xff, 0x10, 0x0, 0x0, 0x6, 0xff, 0xd0, + 0x9, 0xff, 0xc0, 0x0, 0x0, 0x4f, 0xff, 0x50, + 0x1, 0xdf, 0xfe, 0x75, 0x6b, 0xff, 0xf8, 0x0, + 0x0, 0x1c, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x5b, 0xef, 0xec, 0x81, 0x0, 0x0, + + /* U+0034 "4" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xef, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xc9, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf2, + 0x9f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf6, + 0x9, 0xff, 0x30, 0x0, 0x0, 0x0, 0x1e, 0xfb, + 0x0, 0x9f, 0xf3, 0x0, 0x0, 0x0, 0xb, 0xfe, + 0x10, 0x9, 0xff, 0x30, 0x0, 0x0, 0x6, 0xff, + 0x50, 0x0, 0x9f, 0xf3, 0x0, 0x0, 0x2, 0xff, + 0xa0, 0x0, 0x9, 0xff, 0x30, 0x0, 0x0, 0xcf, + 0xe1, 0x0, 0x0, 0x9f, 0xf3, 0x0, 0x0, 0x7f, + 0xf4, 0x0, 0x0, 0x9, 0xff, 0x30, 0x0, 0x3f, + 0xf9, 0x0, 0x0, 0x0, 0x9f, 0xf3, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x54, 0x99, 0x99, 0x99, 0x99, 0x9d, 0xff, 0xa9, + 0x92, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf3, 0x0, 0x0, + + /* U+0035 "5" */ + 0x0, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x5f, 0xfc, 0xbb, 0xbb, 0xbb, 0xbb, 0x50, + 0x0, 0x8f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0x60, 0x26, 0x76, 0x20, 0x0, 0x0, + 0x7, 0xff, 0x7c, 0xff, 0xff, 0xfc, 0x30, 0x0, + 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, + 0xd, 0xff, 0xf7, 0x20, 0x15, 0xcf, 0xff, 0x40, + 0xe, 0xff, 0x20, 0x0, 0x0, 0xb, 0xff, 0xd0, + 0x0, 0x11, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf8, + 0x37, 0x83, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf6, + 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf2, + 0x3f, 0xff, 0x10, 0x0, 0x0, 0x5, 0xff, 0xc0, + 0xc, 0xff, 0xb0, 0x0, 0x0, 0x3f, 0xff, 0x40, + 0x2, 0xef, 0xfe, 0x85, 0x6a, 0xff, 0xf8, 0x0, + 0x0, 0x2d, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x5b, 0xef, 0xfd, 0x82, 0x0, 0x0, + + /* U+0036 "6" */ + 0x0, 0x0, 0x6, 0xbe, 0xfe, 0xc6, 0x0, 0x0, + 0x0, 0x2, 0xdf, 0xff, 0xff, 0xff, 0xd2, 0x0, + 0x0, 0x2e, 0xff, 0xb7, 0x57, 0xef, 0xfe, 0x10, + 0x0, 0xcf, 0xf6, 0x0, 0x0, 0xc, 0xff, 0x80, + 0x5, 0xff, 0x80, 0x0, 0x0, 0x2, 0xff, 0xd0, + 0xb, 0xff, 0x10, 0x0, 0x0, 0x0, 0x67, 0x50, + 0x1f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xf6, 0x0, 0x15, 0x76, 0x30, 0x0, 0x0, + 0x6f, 0xf4, 0x1a, 0xff, 0xff, 0xfd, 0x40, 0x0, + 0x8f, 0xf4, 0xef, 0xff, 0xff, 0xff, 0xf5, 0x0, + 0x9f, 0xfd, 0xfd, 0x51, 0x3, 0xbf, 0xff, 0x20, + 0xaf, 0xff, 0xc0, 0x0, 0x0, 0xa, 0xff, 0xb0, + 0xaf, 0xff, 0x20, 0x0, 0x0, 0x1, 0xff, 0xf1, + 0x9f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf4, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf6, + 0x6f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf6, + 0x3f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf5, + 0xf, 0xff, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf1, + 0x9, 0xff, 0x80, 0x0, 0x0, 0x4, 0xff, 0xc0, + 0x2, 0xff, 0xf5, 0x0, 0x0, 0x2e, 0xff, 0x40, + 0x0, 0x5f, 0xff, 0xb6, 0x58, 0xff, 0xf9, 0x0, + 0x0, 0x5, 0xef, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x17, 0xce, 0xfe, 0xa4, 0x0, 0x0, + + /* U+0037 "7" */ + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, + 0x4b, 0xbb, 0xbb, 0xbb, 0xbb, 0xbc, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + + /* U+0038 "8" */ + 0x0, 0x0, 0x3a, 0xef, 0xfd, 0x92, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x9f, 0xff, 0x96, 0x6b, 0xff, 0xf6, 0x0, + 0x3, 0xff, 0xe2, 0x0, 0x0, 0x5f, 0xff, 0x10, + 0x8, 0xff, 0x60, 0x0, 0x0, 0xa, 0xff, 0x50, + 0xa, 0xff, 0x20, 0x0, 0x0, 0x6, 0xff, 0x70, + 0xa, 0xff, 0x40, 0x0, 0x0, 0x7, 0xff, 0x60, + 0x6, 0xff, 0xb0, 0x0, 0x0, 0x1e, 0xff, 0x20, + 0x0, 0xdf, 0xfc, 0x41, 0x15, 0xdf, 0xf7, 0x0, + 0x0, 0x1c, 0xff, 0xff, 0xff, 0xfe, 0x50, 0x0, + 0x0, 0x2, 0xcf, 0xff, 0xff, 0xfc, 0x50, 0x0, + 0x0, 0x9f, 0xfe, 0x85, 0x69, 0xff, 0xf9, 0x0, + 0x8, 0xff, 0xb0, 0x0, 0x0, 0x2d, 0xff, 0x70, + 0x1f, 0xfe, 0x0, 0x0, 0x0, 0x2, 0xff, 0xe0, + 0x6f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf4, + 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf6, + 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf6, + 0x7f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf4, + 0x3f, 0xfe, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf0, + 0xc, 0xff, 0xb0, 0x0, 0x0, 0x1d, 0xff, 0x80, + 0x2, 0xef, 0xfe, 0x85, 0x59, 0xff, 0xfc, 0x0, + 0x0, 0x2c, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x5a, 0xef, 0xfd, 0x93, 0x0, 0x0, + + /* U+0039 "9" */ + 0x0, 0x0, 0x5b, 0xef, 0xeb, 0x60, 0x0, 0x0, + 0x0, 0x1c, 0xff, 0xff, 0xff, 0xfd, 0x20, 0x0, + 0x0, 0xdf, 0xff, 0x96, 0x6a, 0xff, 0xf3, 0x0, + 0x9, 0xff, 0xe2, 0x0, 0x0, 0x4f, 0xfd, 0x0, + 0x1f, 0xff, 0x30, 0x0, 0x0, 0x7, 0xff, 0x60, + 0x5f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xff, 0xc0, + 0x8f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf0, + 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf3, + 0x8f, 0xf5, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf5, + 0x6f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf6, + 0x2f, 0xff, 0x20, 0x0, 0x0, 0x7, 0xff, 0xf6, + 0xa, 0xff, 0xd2, 0x0, 0x0, 0x5f, 0xff, 0xf6, + 0x1, 0xef, 0xff, 0xb8, 0x8c, 0xff, 0x9f, 0xf6, + 0x0, 0x2d, 0xff, 0xff, 0xff, 0xe4, 0x6f, 0xf5, + 0x0, 0x0, 0x7c, 0xff, 0xd8, 0x10, 0x7f, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xd0, + 0x1a, 0xb8, 0x0, 0x0, 0x0, 0x4, 0xff, 0x80, + 0xf, 0xfe, 0x0, 0x0, 0x0, 0xc, 0xff, 0x20, + 0x9, 0xff, 0x80, 0x0, 0x0, 0xaf, 0xf9, 0x0, + 0x1, 0xff, 0xfb, 0x65, 0x7d, 0xff, 0xd1, 0x0, + 0x0, 0x3e, 0xff, 0xff, 0xff, 0xfb, 0x10, 0x0, + 0x0, 0x1, 0x7c, 0xff, 0xea, 0x40, 0x0, 0x0, + + /* U+003A ":" */ + 0x2f, 0xff, 0x2, 0xff, 0xf0, 0x2f, 0xff, 0x0, + 0x33, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x33, 0x30, 0x2f, 0xff, 0x2, 0xff, 0xf0, + 0x2f, 0xff, 0x0, + + /* U+003B ";" */ + 0x3f, 0xff, 0x3f, 0xff, 0x3f, 0xff, 0x3, 0x33, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0x33, 0x3f, 0xff, 0x3f, 0xff, + 0x3f, 0xff, 0x0, 0xae, 0x0, 0xdc, 0x6, 0xf7, + 0x2f, 0xc0, 0x5, 0x0, + + /* U+003C "<" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x7d, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x9f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xcf, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x18, 0xef, 0xff, 0xfb, 0x50, + 0x0, 0x0, 0x3a, 0xff, 0xff, 0xe8, 0x20, 0x0, + 0x0, 0x6d, 0xff, 0xff, 0xc5, 0x0, 0x0, 0x0, + 0x2e, 0xff, 0xff, 0x93, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xfa, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xbf, 0xff, 0xfd, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x2, 0x9f, 0xff, 0xff, 0x92, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6d, 0xff, 0xff, 0xc5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4b, 0xff, 0xff, 0xe8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x29, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xdf, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + + /* U+003D "=" */ + 0x2a, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xa9, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2a, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xa9, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + + /* U+003E ">" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3c, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xfe, 0x71, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xa3, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x6d, 0xff, 0xff, 0xc6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4a, 0xff, 0xff, 0xe8, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x17, 0xef, 0xff, 0xfa, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xbf, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xbf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6c, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x2, 0x8e, 0xff, 0xff, 0x92, + 0x0, 0x0, 0x4, 0xbf, 0xff, 0xfd, 0x70, 0x0, + 0x0, 0x17, 0xef, 0xff, 0xfb, 0x40, 0x0, 0x0, + 0x1a, 0xff, 0xff, 0xf9, 0x20, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xd7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xb4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x12, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+003F "?" */ + 0x0, 0x0, 0x5a, 0xef, 0xfd, 0xa4, 0x0, 0x0, + 0x0, 0x2c, 0xff, 0xff, 0xff, 0xff, 0xb1, 0x0, + 0x1, 0xdf, 0xfe, 0x85, 0x69, 0xff, 0xfd, 0x0, + 0x9, 0xff, 0xc1, 0x0, 0x0, 0x2e, 0xff, 0x90, + 0x1f, 0xff, 0x20, 0x0, 0x0, 0x3, 0xff, 0xf0, + 0x5f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf2, + 0x4a, 0xc6, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x36, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x23, 0x31, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xf7, 0x0, 0x0, 0x0, + + /* U+0040 "@" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x16, 0xac, 0xef, + 0xfe, 0xdb, 0x72, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1a, 0xff, 0xff, 0xc8, 0x75, 0x56, + 0x8b, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2d, 0xff, 0xe7, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x6d, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xc0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xa0, 0x0, 0x0, 0x7, 0xff, + 0x50, 0x0, 0x0, 0x7c, 0xfe, 0xb4, 0x0, 0xff, + 0xd0, 0x8, 0xff, 0x30, 0x0, 0x2, 0xff, 0x90, + 0x0, 0x3, 0xdf, 0xff, 0xff, 0xf7, 0x2f, 0xf9, + 0x0, 0xd, 0xfb, 0x0, 0x0, 0x9f, 0xe0, 0x0, + 0x3, 0xff, 0xfb, 0x65, 0xaf, 0xfa, 0xff, 0x60, + 0x0, 0x5f, 0xf1, 0x0, 0x1f, 0xf6, 0x0, 0x1, + 0xef, 0xf5, 0x0, 0x0, 0x6f, 0xff, 0xf3, 0x0, + 0x0, 0xff, 0x50, 0x6, 0xfe, 0x0, 0x0, 0xaf, + 0xf8, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x0, 0x0, + 0xd, 0xf7, 0x0, 0xaf, 0xa0, 0x0, 0x2f, 0xfd, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xc0, 0x0, 0x0, + 0xbf, 0x90, 0xe, 0xf6, 0x0, 0x9, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x5f, 0xf9, 0x0, 0x0, 0xb, + 0xf9, 0x0, 0xff, 0x40, 0x0, 0xef, 0xf1, 0x0, + 0x0, 0x0, 0x5, 0xff, 0x50, 0x0, 0x0, 0xdf, + 0x80, 0x1f, 0xf2, 0x0, 0x1f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf2, 0x0, 0x0, 0x1f, 0xf5, + 0x2, 0xff, 0x20, 0x3, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0x0, 0x0, 0x6, 0xff, 0x10, + 0x2f, 0xf3, 0x0, 0x3f, 0xfb, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xb0, 0x0, 0x0, 0xdf, 0xa0, 0x0, + 0xff, 0x50, 0x1, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x9f, 0xf8, 0x0, 0x0, 0x8f, 0xf2, 0x0, 0xe, + 0xf8, 0x0, 0xe, 0xff, 0x20, 0x0, 0x0, 0x4f, + 0xff, 0x50, 0x0, 0x5f, 0xf8, 0x0, 0x0, 0xaf, + 0xd0, 0x0, 0x8f, 0xfb, 0x0, 0x0, 0x4f, 0xff, + 0xf4, 0x0, 0x8f, 0xfc, 0x0, 0x0, 0x5, 0xff, + 0x40, 0x1, 0xef, 0xfc, 0x66, 0xaf, 0xed, 0xff, + 0xea, 0xef, 0xfc, 0x0, 0x0, 0x0, 0xe, 0xfc, + 0x0, 0x2, 0xef, 0xff, 0xff, 0xe2, 0x8f, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf8, + 0x0, 0x1, 0x9e, 0xfd, 0x80, 0x0, 0x9e, 0xfd, + 0x92, 0x0, 0x3, 0x55, 0x10, 0x0, 0xbf, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xd0, 0x0, 0x0, 0xcf, 0xfb, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xd1, 0x0, 0x0, 0x1, 0xbf, 0xff, + 0xa4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x8f, + 0xff, 0xc1, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xb8, 0x65, 0x55, 0x68, 0xad, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x17, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe8, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x36, + 0xac, 0xde, 0xff, 0xed, 0xa8, 0x30, 0x0, 0x0, + 0x0, 0x0, + + /* U+0041 "A" */ + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xfe, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0x6f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xd0, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf8, 0xa, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0x30, 0x4f, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xd0, 0x0, 0xef, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xf7, 0x0, 0x8, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0x10, 0x0, 0x2f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xb0, + 0x0, 0x0, 0xcf, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xf5, 0x0, 0x0, 0x6, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xd7, 0x77, 0x77, 0x77, 0xdf, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x8, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xfc, 0x0, 0x0, 0x0, 0xef, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf2, 0x0, 0x0, + 0x4f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0x90, 0x0, 0xa, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x0, 0x1, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf6, 0x0, 0x7f, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xc0, 0xd, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0x30, + + /* U+0042 "B" */ + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xeb, 0x71, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x50, 0x0, 0xaf, 0xfd, 0xbb, 0xbb, 0xbc, 0xef, + 0xff, 0xf5, 0x0, 0xaf, 0xf6, 0x0, 0x0, 0x0, + 0x2, 0xbf, 0xfe, 0x0, 0xaf, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0x50, 0xaf, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0x70, 0xaf, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x70, 0xaf, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0x50, + 0xaf, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xfe, + 0x0, 0xaf, 0xf6, 0x0, 0x0, 0x0, 0x26, 0xdf, + 0xf5, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x40, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x60, 0x0, 0xaf, 0xfd, 0xbb, 0xbb, + 0xbc, 0xdf, 0xff, 0xfc, 0x10, 0xaf, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x5d, 0xff, 0xc0, 0xaf, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf4, 0xaf, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf8, + 0xaf, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xfa, 0xaf, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf8, 0xaf, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xf5, 0xaf, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x4d, 0xff, 0xe0, 0xaf, 0xfd, 0xbb, 0xbb, + 0xbb, 0xce, 0xff, 0xff, 0x40, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe5, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xed, 0xa6, 0x0, 0x0, + + /* U+0043 "C" */ + 0x0, 0x0, 0x0, 0x5, 0xad, 0xef, 0xec, 0x93, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6e, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x10, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xfd, 0xba, 0xae, 0xff, 0xfe, 0x30, 0x0, + 0x0, 0xbf, 0xff, 0x81, 0x0, 0x0, 0x4, 0xef, + 0xfe, 0x10, 0x0, 0x8f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xfa, 0x0, 0x1f, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf1, 0x8, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xfc, 0x30, 0xdf, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x10, 0x0, 0x1f, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x10, 0x0, 0xcf, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xd7, + 0x7, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0x90, 0x1f, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf3, 0x0, 0x7f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x2, 0xef, 0xfa, 0x0, + 0x0, 0xcf, 0xff, 0x81, 0x0, 0x0, 0x6, 0xef, + 0xfe, 0x10, 0x0, 0x1, 0xcf, 0xff, 0xfc, 0xa9, + 0xbf, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x16, 0xbd, 0xef, 0xec, 0x82, 0x0, + 0x0, 0x0, + + /* U+0044 "D" */ + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xec, 0xa5, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe4, 0x0, 0x0, 0x7f, 0xfd, 0xbb, 0xbb, + 0xbc, 0xdf, 0xff, 0xff, 0x50, 0x0, 0x7f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x5d, 0xff, 0xf3, 0x0, + 0x7f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xfd, 0x0, 0x7f, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x50, 0x7f, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xb0, 0x7f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf0, + 0x7f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xf3, 0x7f, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xf5, 0x7f, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf6, 0x7f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf6, + 0x7f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf6, 0x7f, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf5, 0x7f, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf2, 0x7f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf0, + 0x7f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xa0, 0x7f, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x40, 0x7f, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xfc, 0x0, 0x7f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x5d, 0xff, 0xf3, 0x0, + 0x7f, 0xfd, 0xbb, 0xbb, 0xbb, 0xdf, 0xff, 0xff, + 0x50, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd3, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0xdc, 0x83, 0x0, 0x0, 0x0, + + /* U+0045 "E" */ + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf1, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf1, 0x7f, 0xfe, 0xbb, 0xbb, 0xbb, 0xbb, + 0xbb, 0xbb, 0xb1, 0x7f, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x30, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x30, 0x7f, 0xfd, 0xbb, 0xbb, + 0xbb, 0xbb, 0xbb, 0xbb, 0x20, 0x7f, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfd, 0xbb, 0xbb, + 0xbb, 0xbb, 0xbb, 0xbb, 0xb7, 0x7f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + + /* U+0046 "F" */ + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf0, 0x7f, 0xfe, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, + 0xbb, 0x7, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x50, 0x7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x7f, 0xfe, + 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0x30, 0x7, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0047 "G" */ + 0x0, 0x0, 0x0, 0x3, 0x8c, 0xdf, 0xfe, 0xc9, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x4, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x30, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xfe, 0xba, 0xab, 0xef, 0xff, 0xf4, + 0x0, 0x0, 0x8, 0xff, 0xfb, 0x30, 0x0, 0x0, + 0x3, 0xcf, 0xff, 0x20, 0x0, 0x4f, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xb0, 0x0, + 0xef, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xf2, 0x5, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xc3, 0xb, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xff, 0xfd, 0x4f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, 0xfd, 0x3f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x9b, 0xbb, 0xbb, + 0xbf, 0xfd, 0xf, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xfd, 0xc, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xfd, + 0x6, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xfd, 0x0, 0xef, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xfd, 0x0, 0x5f, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xcf, + 0xfd, 0x0, 0x7, 0xff, 0xfe, 0x71, 0x0, 0x0, + 0x5, 0xaf, 0xff, 0xf9, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xec, 0xcd, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x3, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x81, 0x0, 0x0, 0x0, 0x0, 0x2, 0x7b, 0xde, + 0xfe, 0xc9, 0x50, 0x0, 0x0, + + /* U+0048 "H" */ + 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0x87, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xf8, 0x7f, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0x87, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf8, 0x7f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x87, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xf8, 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0x87, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xf8, 0x7f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0x87, 0xff, 0xeb, + 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xdf, 0xf8, 0x7f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x87, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0x87, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xf8, 0x7f, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x87, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf8, + 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0x87, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xf8, 0x7f, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0x87, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf8, 0x7f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x87, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xf8, 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0x80, + + /* U+0049 "I" */ + 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, + 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, + 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, + 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, + 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, + 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, + + /* U+004A "J" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xf8, 0x0, 0x1, 0x0, 0x0, 0x0, 0x8f, 0xf8, + 0xe, 0xfb, 0x0, 0x0, 0x0, 0x8f, 0xf7, 0xf, + 0xfd, 0x0, 0x0, 0x0, 0xaf, 0xf6, 0xd, 0xff, + 0x30, 0x0, 0x0, 0xef, 0xf2, 0x9, 0xff, 0xc1, + 0x0, 0x9, 0xff, 0xe0, 0x2, 0xff, 0xff, 0xcb, + 0xef, 0xff, 0x60, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x2, 0x9d, 0xff, 0xd9, 0x30, + 0x0, + + /* U+004B "K" */ + 0xaf, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x50, 0xaf, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf5, 0x0, 0xaf, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x50, 0x0, 0xaf, 0xf6, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xf4, 0x0, 0x0, + 0xaf, 0xf6, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x40, + 0x0, 0x0, 0xaf, 0xf6, 0x0, 0x0, 0xb, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0xaf, 0xf6, 0x0, 0x0, + 0xbf, 0xff, 0x30, 0x0, 0x0, 0x0, 0xaf, 0xf6, + 0x0, 0xb, 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xf6, 0x0, 0xbf, 0xfe, 0x20, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xf6, 0xa, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf6, 0xaf, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfe, + 0xff, 0xdc, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xfd, 0x11, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xd1, 0x0, 0x5f, 0xff, + 0x50, 0x0, 0x0, 0x0, 0xaf, 0xfd, 0x10, 0x0, + 0xa, 0xff, 0xf2, 0x0, 0x0, 0x0, 0xaf, 0xf6, + 0x0, 0x0, 0x1, 0xef, 0xfc, 0x0, 0x0, 0x0, + 0xaf, 0xf6, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x80, + 0x0, 0x0, 0xaf, 0xf6, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xf4, 0x0, 0x0, 0xaf, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xfe, 0x10, 0x0, 0xaf, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xb0, 0x0, + 0xaf, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf7, 0x0, 0xaf, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x30, 0xaf, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xd0, + + /* U+004C "L" */ + 0x9f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfd, + 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0x89, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb0, + + /* U+004D "M" */ + 0x9f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x49, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf4, 0x9f, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0x49, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xf4, 0x9f, 0xfa, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfc, + 0xff, 0x49, 0xff, 0x5f, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xfb, 0xaf, 0xf4, 0x9f, 0xf5, 0xaf, + 0xf2, 0x0, 0x0, 0x0, 0x1, 0xff, 0x6a, 0xff, + 0x49, 0xff, 0x54, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x6f, 0xf1, 0xaf, 0xf4, 0x9f, 0xf5, 0xe, 0xfc, + 0x0, 0x0, 0x0, 0xb, 0xfb, 0xa, 0xff, 0x49, + 0xff, 0x50, 0x9f, 0xf2, 0x0, 0x0, 0x1, 0xff, + 0x50, 0xaf, 0xf4, 0x9f, 0xf5, 0x4, 0xff, 0x70, + 0x0, 0x0, 0x6f, 0xf0, 0xa, 0xff, 0x49, 0xff, + 0x50, 0xe, 0xfc, 0x0, 0x0, 0xc, 0xfa, 0x0, + 0xaf, 0xf4, 0x9f, 0xf5, 0x0, 0x9f, 0xf2, 0x0, + 0x1, 0xff, 0x50, 0xa, 0xff, 0x49, 0xff, 0x50, + 0x4, 0xff, 0x70, 0x0, 0x7f, 0xf0, 0x0, 0xaf, + 0xf4, 0x9f, 0xf5, 0x0, 0xe, 0xfc, 0x0, 0xc, + 0xfa, 0x0, 0xa, 0xff, 0x49, 0xff, 0x50, 0x0, + 0x9f, 0xf2, 0x2, 0xff, 0x40, 0x0, 0xaf, 0xf4, + 0x9f, 0xf5, 0x0, 0x3, 0xff, 0x70, 0x7f, 0xe0, + 0x0, 0xa, 0xff, 0x49, 0xff, 0x50, 0x0, 0xe, + 0xfc, 0xc, 0xf9, 0x0, 0x0, 0xaf, 0xf4, 0x9f, + 0xf5, 0x0, 0x0, 0x9f, 0xf3, 0xff, 0x30, 0x0, + 0xa, 0xff, 0x49, 0xff, 0x50, 0x0, 0x3, 0xff, + 0xdf, 0xe0, 0x0, 0x0, 0xaf, 0xf4, 0x9f, 0xf5, + 0x0, 0x0, 0xe, 0xff, 0xf8, 0x0, 0x0, 0xa, + 0xff, 0x49, 0xff, 0x50, 0x0, 0x0, 0x8f, 0xff, + 0x30, 0x0, 0x0, 0xaf, 0xf4, 0x9f, 0xf5, 0x0, + 0x0, 0x3, 0xff, 0xd0, 0x0, 0x0, 0xa, 0xff, + 0x40, + + /* U+004E "N" */ + 0x7f, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0x97, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xf9, 0x7f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0x97, 0xff, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf9, 0x7f, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x5, 0xff, 0x97, + 0xff, 0xaf, 0xff, 0x40, 0x0, 0x0, 0x0, 0x5f, + 0xf9, 0x7f, 0xf7, 0x8f, 0xfe, 0x10, 0x0, 0x0, + 0x5, 0xff, 0x97, 0xff, 0x70, 0xdf, 0xfa, 0x0, + 0x0, 0x0, 0x5f, 0xf9, 0x7f, 0xf7, 0x3, 0xff, + 0xf4, 0x0, 0x0, 0x5, 0xff, 0x97, 0xff, 0x70, + 0x8, 0xff, 0xe1, 0x0, 0x0, 0x5f, 0xf9, 0x7f, + 0xf7, 0x0, 0xd, 0xff, 0xa0, 0x0, 0x5, 0xff, + 0x97, 0xff, 0x70, 0x0, 0x3f, 0xff, 0x40, 0x0, + 0x5f, 0xf9, 0x7f, 0xf7, 0x0, 0x0, 0x8f, 0xfe, + 0x10, 0x5, 0xff, 0x97, 0xff, 0x70, 0x0, 0x0, + 0xdf, 0xfa, 0x0, 0x5f, 0xf9, 0x7f, 0xf7, 0x0, + 0x0, 0x3, 0xff, 0xf4, 0x5, 0xff, 0x97, 0xff, + 0x70, 0x0, 0x0, 0x8, 0xff, 0xe1, 0x5f, 0xf9, + 0x7f, 0xf7, 0x0, 0x0, 0x0, 0xd, 0xff, 0xa5, + 0xff, 0x97, 0xff, 0x70, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xaf, 0xf9, 0x7f, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x97, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf9, 0x7f, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x97, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xf9, 0x7f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x90, + + /* U+004F "O" */ + 0x0, 0x0, 0x0, 0x5, 0x9d, 0xef, 0xed, 0x94, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6e, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x40, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xfd, 0xba, 0xbe, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xa2, 0x0, + 0x0, 0x3, 0xbf, 0xff, 0x90, 0x0, 0x0, 0x8f, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0x50, 0x0, 0x1f, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xfe, 0x0, 0x8, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf7, + 0x0, 0xef, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xc0, 0x2f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x15, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xf3, 0x6f, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x57, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf6, 0x7f, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0x55, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xf3, 0x2f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x10, 0xef, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xd0, + 0x9, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xf7, 0x0, 0x2f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, + 0x8f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x60, 0x0, 0x0, 0xbf, 0xff, 0x91, 0x0, + 0x0, 0x2, 0xaf, 0xff, 0x90, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xfd, 0xa9, 0xad, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x5e, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xad, 0xff, 0xed, 0x94, 0x0, 0x0, 0x0, + 0x0, + + /* U+0050 "P" */ + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xc8, 0x30, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x8f, 0xfd, 0xbb, 0xbb, 0xbb, 0xcd, + 0xff, 0xff, 0x90, 0x8f, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x1a, 0xff, 0xf3, 0x8f, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xfa, 0x8f, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, 0x8f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfe, 0x8f, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfe, + 0x8f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xfb, 0x8f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf6, 0x8f, 0xf8, 0x0, 0x0, 0x0, 0x3, + 0x8f, 0xff, 0xe0, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x30, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc2, 0x0, 0x8f, 0xfd, 0xbb, + 0xbb, 0xbb, 0xa9, 0x62, 0x0, 0x0, 0x8f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0051 "Q" */ + 0x0, 0x0, 0x0, 0x5, 0x9d, 0xef, 0xed, 0x94, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6e, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x40, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xfd, 0xba, 0xbd, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xa2, 0x0, + 0x0, 0x2, 0xaf, 0xff, 0xa0, 0x0, 0x0, 0x7f, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x60, 0x0, 0x1f, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xfe, 0x10, 0x8, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf7, + 0x0, 0xef, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xd0, 0x2f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x15, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xf4, 0x6f, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x57, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf6, 0x6f, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0x55, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xf3, 0x2f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x10, 0xef, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xc0, + 0x8, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x73, 0x0, + 0x0, 0xdf, 0xf7, 0x0, 0x1f, 0xff, 0x60, 0x0, + 0x0, 0x1f, 0xfc, 0x30, 0x7f, 0xfe, 0x0, 0x0, + 0x6f, 0xff, 0x50, 0x0, 0x3, 0xdf, 0xff, 0xaf, + 0xff, 0x60, 0x0, 0x0, 0xaf, 0xff, 0x92, 0x0, + 0x0, 0x4e, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xfd, 0xa9, 0xad, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x6e, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0xdf, 0xfd, 0x40, 0x0, 0x0, 0x0, + 0x5, 0xad, 0xef, 0xfc, 0x94, 0x0, 0xaf, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4c, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x0, + + /* U+0052 "R" */ + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xed, 0xa5, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x7f, 0xfd, 0x88, + 0x88, 0x88, 0x89, 0xbe, 0xff, 0xfb, 0x0, 0x7, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf4, 0x0, 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xa0, 0x7, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfd, 0x0, 0x7f, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xd0, 0x7, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xfb, 0x0, 0x7f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2e, 0xff, 0x60, 0x7, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x13, 0x8f, 0xff, 0xd0, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd2, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x80, 0x0, 0x0, 0x7f, 0xfd, + 0xaa, 0xab, 0xcf, 0xff, 0xd4, 0x0, 0x0, 0x0, + 0x7, 0xff, 0x90, 0x0, 0x0, 0x2a, 0xff, 0xe3, + 0x0, 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf3, 0x0, 0x0, 0x7, 0xff, 0x90, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xe1, 0x0, 0x0, + 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xa0, 0x0, 0x7, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0x40, 0x0, 0x7f, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfe, 0x0, 0x7, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf8, 0x0, 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf3, 0x7, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xc0, 0x7f, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x60, + + /* U+0053 "S" */ + 0x0, 0x0, 0x5, 0xad, 0xff, 0xed, 0xa4, 0x0, + 0x0, 0x0, 0x0, 0x4d, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x30, 0x0, 0x0, 0x4f, 0xff, 0xfe, 0xbb, + 0xbe, 0xff, 0xff, 0x40, 0x0, 0x1e, 0xff, 0xb2, + 0x0, 0x0, 0x3, 0xcf, 0xfe, 0x10, 0x6, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf8, 0x0, + 0x9f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xc0, 0xa, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xcb, 0x0, 0x7f, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfc, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xfb, 0x84, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xdf, 0xff, 0xff, 0xff, 0xc7, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x5a, 0xef, 0xff, 0xff, 0xff, + 0xa1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x37, 0xae, + 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0x9f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, 0x54, 0xab, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, + 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xa3, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xf8, 0xd, 0xff, 0xc1, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0x40, 0x4f, 0xff, 0xe6, + 0x10, 0x0, 0x0, 0x6e, 0xff, 0xc0, 0x0, 0x6f, + 0xff, 0xff, 0xdb, 0xbd, 0xff, 0xff, 0xd1, 0x0, + 0x0, 0x4d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb1, + 0x0, 0x0, 0x0, 0x4, 0x9c, 0xef, 0xfe, 0xc8, + 0x30, 0x0, 0x0, + + /* U+0054 "T" */ + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x3b, 0xbb, 0xbb, 0xbb, 0xef, + 0xfc, 0xbb, 0xbb, 0xbb, 0x90, 0x0, 0x0, 0x0, + 0xc, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf4, 0x0, + 0x0, 0x0, 0x0, + + /* U+0055 "U" */ + 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0x97, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xf9, 0x7f, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0x97, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, 0x7f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x97, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xf9, 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0x97, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf9, 0x7f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0x97, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, 0x7f, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0x97, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xf9, 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0x96, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xf8, 0x6f, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x84, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf6, + 0x2f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0x40, 0xef, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf1, 0x9, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xfb, 0x0, 0x2f, 0xff, 0xd4, + 0x0, 0x0, 0x3, 0xcf, 0xff, 0x40, 0x0, 0x6f, + 0xff, 0xff, 0xdc, 0xcf, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x6e, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x50, + 0x0, 0x0, 0x0, 0x6, 0xad, 0xef, 0xfd, 0xa6, + 0x0, 0x0, 0x0, + + /* U+0056 "V" */ + 0xaf, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xe0, 0x4f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0x80, 0xd, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0x20, 0x7, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xfb, 0x0, 0x1, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf5, 0x0, 0x0, + 0xbf, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xe0, 0x0, 0x0, 0x5f, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0x90, 0x0, 0x0, 0xe, 0xff, + 0x10, 0x0, 0x0, 0x0, 0xc, 0xff, 0x20, 0x0, + 0x0, 0x9, 0xff, 0x70, 0x0, 0x0, 0x0, 0x2f, + 0xfc, 0x0, 0x0, 0x0, 0x2, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x8f, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xf2, 0x0, 0x0, 0x0, 0xdf, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xf8, 0x0, 0x0, 0x3, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0xf, 0xfe, + 0x0, 0x0, 0x9, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0x30, 0x0, 0xf, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0x90, 0x0, + 0x5f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xe0, 0x0, 0xbf, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xf5, 0x1, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xfa, + 0x6, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xc, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0x6f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xef, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, + + /* U+0057 "W" */ + 0x8f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfa, 0x4f, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf5, 0xf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xf1, 0xc, 0xff, 0x30, + 0x0, 0x0, 0x0, 0xbf, 0xdc, 0xfe, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xd0, 0x7, 0xff, 0x70, 0x0, + 0x0, 0x0, 0xff, 0x98, 0xff, 0x30, 0x0, 0x0, + 0x5, 0xff, 0x80, 0x3, 0xff, 0xb0, 0x0, 0x0, + 0x4, 0xff, 0x53, 0xff, 0x70, 0x0, 0x0, 0x9, + 0xff, 0x40, 0x0, 0xff, 0xe0, 0x0, 0x0, 0x8, + 0xff, 0x10, 0xff, 0xc0, 0x0, 0x0, 0xd, 0xff, + 0x0, 0x0, 0xbf, 0xf2, 0x0, 0x0, 0xd, 0xfc, + 0x0, 0xbf, 0xf1, 0x0, 0x0, 0x1f, 0xfb, 0x0, + 0x0, 0x6f, 0xf6, 0x0, 0x0, 0x1f, 0xf8, 0x0, + 0x6f, 0xf5, 0x0, 0x0, 0x5f, 0xf7, 0x0, 0x0, + 0x2f, 0xfa, 0x0, 0x0, 0x6f, 0xf3, 0x0, 0x2f, + 0xf9, 0x0, 0x0, 0x9f, 0xf2, 0x0, 0x0, 0xe, + 0xfd, 0x0, 0x0, 0xaf, 0xf0, 0x0, 0xd, 0xfe, + 0x0, 0x0, 0xdf, 0xe0, 0x0, 0x0, 0xa, 0xff, + 0x10, 0x0, 0xef, 0xa0, 0x0, 0x9, 0xff, 0x20, + 0x1, 0xff, 0xa0, 0x0, 0x0, 0x5, 0xff, 0x50, + 0x3, 0xff, 0x60, 0x0, 0x5, 0xff, 0x60, 0x4, + 0xff, 0x50, 0x0, 0x0, 0x1, 0xff, 0x80, 0x8, + 0xff, 0x20, 0x0, 0x0, 0xff, 0xa0, 0x8, 0xff, + 0x10, 0x0, 0x0, 0x0, 0xdf, 0xc0, 0xc, 0xfd, + 0x0, 0x0, 0x0, 0xcf, 0xe0, 0xc, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf0, 0x1f, 0xf9, 0x0, + 0x0, 0x0, 0x7f, 0xf3, 0xf, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xf3, 0x5f, 0xf4, 0x0, 0x0, + 0x0, 0x3f, 0xf6, 0x4f, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xf7, 0x8f, 0xf0, 0x0, 0x0, 0x0, + 0xe, 0xf9, 0x8f, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xfa, 0xcf, 0xb0, 0x0, 0x0, 0x0, 0xa, + 0xfc, 0xbf, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xfe, 0xff, 0x70, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xef, 0x70, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfa, 0x0, 0x0, + 0x0, + + /* U+0058 "X" */ + 0x7, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x20, 0x0, 0xbf, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf6, 0x0, 0x0, 0x1e, + 0xff, 0x80, 0x0, 0x0, 0x0, 0xa, 0xff, 0xa0, + 0x0, 0x0, 0x5, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x6f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfe, + 0x10, 0x0, 0x3, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xa0, 0x0, 0x1d, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf5, 0x0, + 0xaf, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x16, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xbf, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfd, 0x8, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf2, 0x0, 0xdf, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0x60, 0x0, 0x3f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfb, 0x0, + 0x0, 0x7, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0xcf, 0xfd, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xa0, 0x0, 0x1, 0xef, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf5, 0x0, 0xb, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0x20, 0x7f, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xc0, + + /* U+0059 "Y" */ + 0x9f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xb0, 0xd, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x10, 0x3, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf5, + 0x0, 0x0, 0x9f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xa0, 0x0, 0x0, 0xd, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x6f, 0xfe, 0x10, 0x0, 0x0, + 0x3, 0xff, 0xf5, 0x0, 0x0, 0x1, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfe, 0x10, 0x0, + 0xb, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xa0, 0x0, 0x5f, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xf4, 0x1, 0xef, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfd, + 0x9, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0x9f, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+005A "Z" */ + 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x50, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf5, 0x1, 0xbb, 0xbb, 0xbb, 0xbb, + 0xbb, 0xbb, 0xdf, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2e, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xdf, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xef, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xcb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0x76, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfb, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb0, + + /* U+005B "[" */ + 0xef, 0xff, 0xff, 0x5e, 0xff, 0xff, 0xf5, 0xef, + 0xf5, 0x55, 0x1e, 0xff, 0x0, 0x0, 0xef, 0xf0, + 0x0, 0xe, 0xff, 0x0, 0x0, 0xef, 0xf0, 0x0, + 0xe, 0xff, 0x0, 0x0, 0xef, 0xf0, 0x0, 0xe, + 0xff, 0x0, 0x0, 0xef, 0xf0, 0x0, 0xe, 0xff, + 0x0, 0x0, 0xef, 0xf0, 0x0, 0xe, 0xff, 0x0, + 0x0, 0xef, 0xf0, 0x0, 0xe, 0xff, 0x0, 0x0, + 0xef, 0xf0, 0x0, 0xe, 0xff, 0x0, 0x0, 0xef, + 0xf0, 0x0, 0xe, 0xff, 0x0, 0x0, 0xef, 0xf0, + 0x0, 0xe, 0xff, 0x0, 0x0, 0xef, 0xf0, 0x0, + 0xe, 0xff, 0x0, 0x0, 0xef, 0xf0, 0x0, 0xe, + 0xff, 0x0, 0x0, 0xef, 0xf5, 0x55, 0x1e, 0xff, + 0xff, 0xf5, 0xef, 0xff, 0xff, 0x50, + + /* U+005C "\\" */ + 0xdf, 0x60, 0x0, 0x0, 0x9, 0xfb, 0x0, 0x0, + 0x0, 0x4f, 0xf0, 0x0, 0x0, 0x0, 0xff, 0x40, + 0x0, 0x0, 0xb, 0xf8, 0x0, 0x0, 0x0, 0x6f, + 0xd0, 0x0, 0x0, 0x2, 0xff, 0x20, 0x0, 0x0, + 0xd, 0xf6, 0x0, 0x0, 0x0, 0x8f, 0xb0, 0x0, + 0x0, 0x4, 0xff, 0x0, 0x0, 0x0, 0xf, 0xf4, + 0x0, 0x0, 0x0, 0xaf, 0x90, 0x0, 0x0, 0x6, + 0xfd, 0x0, 0x0, 0x0, 0x1f, 0xf2, 0x0, 0x0, + 0x0, 0xdf, 0x70, 0x0, 0x0, 0x8, 0xfb, 0x0, + 0x0, 0x0, 0x3f, 0xf0, 0x0, 0x0, 0x0, 0xef, + 0x40, 0x0, 0x0, 0xa, 0xf9, 0x0, 0x0, 0x0, + 0x5f, 0xe0, 0x0, 0x0, 0x1, 0xff, 0x20, 0x0, + 0x0, 0xc, 0xf7, 0x0, 0x0, 0x0, 0x8f, 0xb0, + + /* U+005D "]" */ + 0x7f, 0xff, 0xff, 0xc7, 0xff, 0xff, 0xfc, 0x25, + 0x55, 0xff, 0xc0, 0x0, 0xf, 0xfc, 0x0, 0x0, + 0xff, 0xc0, 0x0, 0xf, 0xfc, 0x0, 0x0, 0xff, + 0xc0, 0x0, 0xf, 0xfc, 0x0, 0x0, 0xff, 0xc0, + 0x0, 0xf, 0xfc, 0x0, 0x0, 0xff, 0xc0, 0x0, + 0xf, 0xfc, 0x0, 0x0, 0xff, 0xc0, 0x0, 0xf, + 0xfc, 0x0, 0x0, 0xff, 0xc0, 0x0, 0xf, 0xfc, + 0x0, 0x0, 0xff, 0xc0, 0x0, 0xf, 0xfc, 0x0, + 0x0, 0xff, 0xc0, 0x0, 0xf, 0xfc, 0x0, 0x0, + 0xff, 0xc0, 0x0, 0xf, 0xfc, 0x0, 0x0, 0xff, + 0xc0, 0x0, 0xf, 0xfc, 0x0, 0x0, 0xff, 0xc0, + 0x0, 0xf, 0xfc, 0x25, 0x55, 0xff, 0xc7, 0xff, + 0xff, 0xfc, 0x7f, 0xff, 0xff, 0xc0, + + /* U+005E "^" */ + 0x0, 0x0, 0x0, 0x68, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xf5, 0xff, 0x60, 0x0, 0x0, 0x0, 0xd, + 0xfc, 0xc, 0xfd, 0x0, 0x0, 0x0, 0x4, 0xff, + 0x50, 0x5f, 0xf4, 0x0, 0x0, 0x0, 0xbf, 0xe0, + 0x0, 0xef, 0xb0, 0x0, 0x0, 0x2f, 0xf8, 0x0, + 0x8, 0xff, 0x20, 0x0, 0x9, 0xff, 0x20, 0x0, + 0x1f, 0xf9, 0x0, 0x1, 0xff, 0xb0, 0x0, 0x0, + 0xbf, 0xf1, 0x0, 0x7f, 0xf5, 0x0, 0x0, 0x4, + 0xff, 0x80, 0xe, 0xfe, 0x0, 0x0, 0x0, 0xd, + 0xfe, 0x0, + + /* U+005F "_" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf0, + + /* U+0060 "`" */ + 0x26, 0x66, 0x10, 0x0, 0xdf, 0xf9, 0x0, 0x2, + 0xef, 0xf1, 0x0, 0x4, 0xff, 0x80, 0x0, 0x6, + 0xff, 0x10, + + /* U+0061 "a" */ + 0x0, 0x1, 0x7b, 0xef, 0xfe, 0xc8, 0x10, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, + 0x4, 0xff, 0xfa, 0x65, 0x58, 0xdf, 0xff, 0x10, + 0xc, 0xff, 0x50, 0x0, 0x0, 0xd, 0xff, 0x60, + 0x2f, 0xfc, 0x0, 0x0, 0x0, 0x6, 0xff, 0x80, + 0x2, 0x43, 0x0, 0x0, 0x0, 0x3, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x5a, 0xff, 0x90, + 0x0, 0x0, 0x48, 0xad, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xdb, 0xff, 0x90, + 0xc, 0xff, 0xfd, 0x97, 0x41, 0x3, 0xff, 0x90, + 0x6f, 0xfe, 0x30, 0x0, 0x0, 0x5, 0xff, 0x90, + 0xbf, 0xf6, 0x0, 0x0, 0x0, 0x7, 0xff, 0x90, + 0xcf, 0xf4, 0x0, 0x0, 0x0, 0xd, 0xff, 0xa0, + 0xaf, 0xfa, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xa0, + 0x3f, 0xff, 0xb5, 0x34, 0x8e, 0xff, 0xff, 0xb0, + 0x7, 0xff, 0xff, 0xff, 0xff, 0xe4, 0xef, 0xe0, + 0x0, 0x3a, 0xef, 0xfe, 0xb6, 0x0, 0xaf, 0xf4, + + /* U+0062 "b" */ + 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf0, 0x2a, + 0xef, 0xeb, 0x50, 0x0, 0xd, 0xff, 0x5f, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0xdf, 0xff, 0xfb, 0x65, + 0x8e, 0xff, 0xb0, 0xd, 0xff, 0xf7, 0x0, 0x0, + 0x1d, 0xff, 0x60, 0xdf, 0xfa, 0x0, 0x0, 0x0, + 0x3f, 0xfd, 0xd, 0xff, 0x30, 0x0, 0x0, 0x0, + 0xcf, 0xf3, 0xdf, 0xe0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0x6d, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xf7, 0xdf, 0xb0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0x8d, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf7, + 0xdf, 0xd0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x5d, + 0xff, 0x10, 0x0, 0x0, 0x0, 0xdf, 0xf1, 0xdf, + 0xf8, 0x0, 0x0, 0x0, 0x4f, 0xfc, 0xd, 0xff, + 0xf5, 0x0, 0x0, 0x2e, 0xff, 0x40, 0xdf, 0xef, + 0xfb, 0x65, 0x8f, 0xff, 0x90, 0xd, 0xfc, 0x6f, + 0xff, 0xff, 0xff, 0x80, 0x0, 0xdf, 0xc0, 0x3a, + 0xef, 0xea, 0x30, 0x0, 0x0, + + /* U+0063 "c" */ + 0x0, 0x0, 0x5a, 0xef, 0xfd, 0x81, 0x0, 0x0, + 0x1, 0xcf, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0xdf, 0xfe, 0x85, 0x6a, 0xff, 0xf5, 0x0, 0x9f, + 0xfc, 0x0, 0x0, 0x5, 0xff, 0xe0, 0x1f, 0xfe, + 0x10, 0x0, 0x0, 0xb, 0xff, 0x46, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x37, 0x51, 0x9f, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x42, 0x6, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x4f, 0xf9, 0x1f, 0xfe, 0x0, 0x0, 0x0, 0xa, + 0xff, 0x50, 0x9f, 0xfa, 0x0, 0x0, 0x5, 0xff, + 0xe0, 0x0, 0xdf, 0xfd, 0x75, 0x6a, 0xff, 0xf4, + 0x0, 0x1, 0xcf, 0xff, 0xff, 0xff, 0xe4, 0x0, + 0x0, 0x0, 0x5a, 0xef, 0xfc, 0x71, 0x0, 0x0, + + /* U+0064 "d" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xf8, 0x0, 0x0, 0x7c, + 0xef, 0xd8, 0x4, 0xff, 0x80, 0x2, 0xef, 0xff, + 0xff, 0xfe, 0x6f, 0xf8, 0x1, 0xef, 0xfd, 0x75, + 0x7d, 0xff, 0xff, 0x80, 0xbf, 0xfa, 0x0, 0x0, + 0xb, 0xff, 0xf8, 0x2f, 0xfd, 0x0, 0x0, 0x0, + 0xe, 0xff, 0x87, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x8f, 0xf8, 0xaf, 0xf3, 0x0, 0x0, 0x0, 0x3, + 0xff, 0x8c, 0xff, 0x10, 0x0, 0x0, 0x0, 0x1f, + 0xf8, 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0x8c, 0xff, 0x10, 0x0, 0x0, 0x0, 0x1f, 0xf8, + 0xaf, 0xf3, 0x0, 0x0, 0x0, 0x2, 0xff, 0x87, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x6f, 0xf8, 0x1f, + 0xfe, 0x0, 0x0, 0x0, 0xd, 0xff, 0x80, 0x9f, + 0xfb, 0x0, 0x0, 0x9, 0xff, 0xf8, 0x0, 0xdf, + 0xfd, 0x75, 0x7d, 0xfe, 0xff, 0x80, 0x1, 0xcf, + 0xff, 0xff, 0xfe, 0x4f, 0xf8, 0x0, 0x0, 0x6b, + 0xef, 0xd9, 0x11, 0xff, 0x80, + + /* U+0065 "e" */ + 0x0, 0x0, 0x39, 0xdf, 0xfd, 0x93, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0xbf, 0xfe, 0x85, 0x58, 0xef, 0xfa, 0x0, + 0x7, 0xff, 0xc1, 0x0, 0x0, 0x1c, 0xff, 0x50, + 0xe, 0xfe, 0x10, 0x0, 0x0, 0x1, 0xff, 0xd0, + 0x5f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf2, + 0x9f, 0xf8, 0x55, 0x55, 0x55, 0x55, 0xaf, 0xf6, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0xbf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x7a, 0x82, + 0x1f, 0xff, 0x20, 0x0, 0x0, 0x1, 0xff, 0xf2, + 0x9, 0xff, 0xd2, 0x0, 0x0, 0x1c, 0xff, 0xa0, + 0x0, 0xdf, 0xff, 0x95, 0x58, 0xef, 0xfe, 0x10, + 0x0, 0x1b, 0xff, 0xff, 0xff, 0xff, 0xc2, 0x0, + 0x0, 0x0, 0x4a, 0xdf, 0xfe, 0xb5, 0x0, 0x0, + + /* U+0066 "f" */ + 0x0, 0x0, 0x5c, 0xef, 0xeb, 0x0, 0x8, 0xff, + 0xff, 0xfb, 0x0, 0xf, 0xff, 0xda, 0xa6, 0x0, + 0x3f, 0xfc, 0x0, 0x0, 0x0, 0x4f, 0xf9, 0x0, + 0x0, 0x0, 0x4f, 0xf8, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xff, 0xc0, 0xcf, 0xff, 0xff, 0xff, 0xc0, + 0x23, 0x6f, 0xf9, 0x33, 0x20, 0x0, 0x4f, 0xf8, + 0x0, 0x0, 0x0, 0x4f, 0xf8, 0x0, 0x0, 0x0, + 0x4f, 0xf8, 0x0, 0x0, 0x0, 0x4f, 0xf8, 0x0, + 0x0, 0x0, 0x4f, 0xf8, 0x0, 0x0, 0x0, 0x4f, + 0xf8, 0x0, 0x0, 0x0, 0x4f, 0xf8, 0x0, 0x0, + 0x0, 0x4f, 0xf8, 0x0, 0x0, 0x0, 0x4f, 0xf8, + 0x0, 0x0, 0x0, 0x4f, 0xf8, 0x0, 0x0, 0x0, + 0x4f, 0xf8, 0x0, 0x0, 0x0, 0x4f, 0xf8, 0x0, + 0x0, 0x0, 0x4f, 0xf8, 0x0, 0x0, 0x0, 0x4f, + 0xf8, 0x0, 0x0, + + /* U+0067 "g" */ + 0x0, 0x0, 0x7c, 0xef, 0xd9, 0x10, 0xef, 0xb0, + 0x2, 0xef, 0xff, 0xff, 0xff, 0x4e, 0xfb, 0x1, + 0xef, 0xfd, 0x75, 0x7d, 0xff, 0xff, 0xb0, 0xaf, + 0xfa, 0x0, 0x0, 0x9, 0xff, 0xfb, 0x2f, 0xfd, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xb7, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x6f, 0xfb, 0xbf, 0xf2, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xbd, 0xff, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xfb, 0xef, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xbd, 0xff, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xfb, 0xbf, 0xf2, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xb8, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x5f, 0xfb, 0x2f, 0xfd, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xb0, 0xaf, 0xfa, 0x0, 0x0, 0x9, 0xff, + 0xfb, 0x1, 0xef, 0xfd, 0x75, 0x7c, 0xff, 0xff, + 0xb0, 0x2, 0xdf, 0xff, 0xff, 0xfe, 0x6f, 0xfa, + 0x0, 0x0, 0x7c, 0xef, 0xd8, 0x13, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf7, 0x4c, + 0xa4, 0x0, 0x0, 0x0, 0x8, 0xff, 0x42, 0xff, + 0xc0, 0x0, 0x0, 0x4, 0xff, 0xe0, 0xb, 0xff, + 0xe8, 0x65, 0x7b, 0xff, 0xf5, 0x0, 0x1c, 0xff, + 0xff, 0xff, 0xff, 0xe5, 0x0, 0x0, 0x5, 0xad, + 0xff, 0xdb, 0x60, 0x0, 0x0, + + /* U+0068 "h" */ + 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf0, 0x18, 0xdf, 0xfd, 0x91, + 0x0, 0xdf, 0xf4, 0xef, 0xff, 0xff, 0xff, 0x30, + 0xdf, 0xff, 0xfd, 0x87, 0x9e, 0xff, 0xe0, 0xdf, + 0xff, 0x70, 0x0, 0x1, 0xef, 0xf4, 0xdf, 0xfa, + 0x0, 0x0, 0x0, 0x7f, 0xf8, 0xdf, 0xf3, 0x0, + 0x0, 0x0, 0x4f, 0xf9, 0xdf, 0xf0, 0x0, 0x0, + 0x0, 0x2f, 0xfa, 0xdf, 0xf0, 0x0, 0x0, 0x0, + 0x2f, 0xfa, 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x2f, + 0xfa, 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xfa, + 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xfa, 0xdf, + 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xfa, 0xdf, 0xf0, + 0x0, 0x0, 0x0, 0x2f, 0xfa, 0xdf, 0xf0, 0x0, + 0x0, 0x0, 0x2f, 0xfa, 0xdf, 0xf0, 0x0, 0x0, + 0x0, 0x2f, 0xfa, 0xdf, 0xf0, 0x0, 0x0, 0x0, + 0x2f, 0xfa, 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x2f, + 0xfa, + + /* U+0069 "i" */ + 0xdf, 0xfd, 0xff, 0xdf, 0xf3, 0x43, 0x0, 0x0, + 0x0, 0xdf, 0xfd, 0xff, 0xdf, 0xfd, 0xff, 0xdf, + 0xfd, 0xff, 0xdf, 0xfd, 0xff, 0xdf, 0xfd, 0xff, + 0xdf, 0xfd, 0xff, 0xdf, 0xfd, 0xff, 0xdf, 0xfd, + 0xff, 0xdf, 0xf0, + + /* U+006A "j" */ + 0x0, 0x0, 0xdf, 0xf0, 0x0, 0xd, 0xff, 0x0, + 0x0, 0xdf, 0xf0, 0x0, 0x3, 0x44, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xf0, 0x0, 0xd, 0xff, 0x0, 0x0, 0xdf, 0xf0, + 0x0, 0xd, 0xff, 0x0, 0x0, 0xdf, 0xf0, 0x0, + 0xd, 0xff, 0x0, 0x0, 0xdf, 0xf0, 0x0, 0xd, + 0xff, 0x0, 0x0, 0xdf, 0xf0, 0x0, 0xd, 0xff, + 0x0, 0x0, 0xdf, 0xf0, 0x0, 0xd, 0xff, 0x0, + 0x0, 0xdf, 0xf0, 0x0, 0xd, 0xff, 0x0, 0x0, + 0xdf, 0xf0, 0x0, 0xd, 0xff, 0x0, 0x0, 0xdf, + 0xf0, 0x0, 0xd, 0xff, 0x0, 0x0, 0xef, 0xe0, + 0x0, 0x1f, 0xfc, 0x9, 0x8d, 0xff, 0x82, 0xff, + 0xff, 0xf2, 0x3e, 0xff, 0xb3, 0x0, + + /* U+006B "k" */ + 0xef, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xf0, 0x0, 0x0, 0x1d, 0xff, + 0xb0, 0xef, 0xf0, 0x0, 0x0, 0xcf, 0xfb, 0x0, + 0xef, 0xf0, 0x0, 0xc, 0xff, 0xb0, 0x0, 0xef, + 0xf0, 0x0, 0xbf, 0xfb, 0x0, 0x0, 0xef, 0xf0, + 0xb, 0xff, 0xb0, 0x0, 0x0, 0xef, 0xf0, 0xaf, + 0xfa, 0x0, 0x0, 0x0, 0xef, 0xfa, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xbe, 0xff, 0x50, 0x0, + 0x0, 0xef, 0xfb, 0x5, 0xff, 0xe1, 0x0, 0x0, + 0xef, 0xf0, 0x0, 0xbf, 0xfa, 0x0, 0x0, 0xef, + 0xf0, 0x0, 0x1f, 0xff, 0x40, 0x0, 0xef, 0xf0, + 0x0, 0x7, 0xff, 0xe0, 0x0, 0xef, 0xf0, 0x0, + 0x0, 0xcf, 0xf9, 0x0, 0xef, 0xf0, 0x0, 0x0, + 0x3f, 0xff, 0x30, 0xef, 0xf0, 0x0, 0x0, 0x8, + 0xff, 0xd0, 0xef, 0xf0, 0x0, 0x0, 0x0, 0xdf, + 0xf8, + + /* U+006C "l" */ + 0xef, 0xee, 0xfe, 0xef, 0xee, 0xfe, 0xef, 0xee, + 0xfe, 0xef, 0xee, 0xfe, 0xef, 0xee, 0xfe, 0xef, + 0xee, 0xfe, 0xef, 0xee, 0xfe, 0xef, 0xee, 0xfe, + 0xef, 0xee, 0xfe, 0xef, 0xee, 0xfe, 0xef, 0xee, + 0xfe, 0xef, 0xe0, + + /* U+006D "m" */ + 0xef, 0x90, 0x29, 0xdf, 0xeb, 0x40, 0x0, 0x3a, + 0xef, 0xea, 0x30, 0xe, 0xf9, 0x5f, 0xff, 0xff, + 0xff, 0x70, 0x6f, 0xff, 0xff, 0xff, 0x50, 0xef, + 0xdf, 0xfb, 0x78, 0xdf, 0xff, 0x7f, 0xfa, 0x78, + 0xdf, 0xff, 0xe, 0xff, 0xf5, 0x0, 0x0, 0xcf, + 0xff, 0xe2, 0x0, 0x1, 0xdf, 0xf5, 0xef, 0xf8, + 0x0, 0x0, 0x4, 0xff, 0xf5, 0x0, 0x0, 0x7, + 0xff, 0x8e, 0xff, 0x30, 0x0, 0x0, 0x2f, 0xff, + 0x0, 0x0, 0x0, 0x4f, 0xf9, 0xef, 0xf0, 0x0, + 0x0, 0x0, 0xff, 0xd0, 0x0, 0x0, 0x3, 0xff, + 0x9e, 0xff, 0x0, 0x0, 0x0, 0xf, 0xfc, 0x0, + 0x0, 0x0, 0x3f, 0xf9, 0xef, 0xe0, 0x0, 0x0, + 0x0, 0xff, 0xc0, 0x0, 0x0, 0x3, 0xff, 0x9e, + 0xfe, 0x0, 0x0, 0x0, 0xf, 0xfc, 0x0, 0x0, + 0x0, 0x3f, 0xf9, 0xef, 0xe0, 0x0, 0x0, 0x0, + 0xff, 0xc0, 0x0, 0x0, 0x3, 0xff, 0x9e, 0xfe, + 0x0, 0x0, 0x0, 0xf, 0xfc, 0x0, 0x0, 0x0, + 0x3f, 0xf9, 0xef, 0xe0, 0x0, 0x0, 0x0, 0xff, + 0xc0, 0x0, 0x0, 0x3, 0xff, 0x9e, 0xfe, 0x0, + 0x0, 0x0, 0xf, 0xfc, 0x0, 0x0, 0x0, 0x3f, + 0xf9, 0xef, 0xe0, 0x0, 0x0, 0x0, 0xff, 0xc0, + 0x0, 0x0, 0x3, 0xff, 0x9e, 0xfe, 0x0, 0x0, + 0x0, 0xf, 0xfc, 0x0, 0x0, 0x0, 0x3f, 0xf9, + 0xef, 0xe0, 0x0, 0x0, 0x0, 0xff, 0xc0, 0x0, + 0x0, 0x3, 0xff, 0x90, + + /* U+006E "n" */ + 0xdf, 0xb0, 0x18, 0xdf, 0xfd, 0x81, 0x0, 0xdf, + 0xb3, 0xef, 0xff, 0xff, 0xfe, 0x30, 0xdf, 0xde, + 0xfd, 0x87, 0x9e, 0xff, 0xd0, 0xdf, 0xff, 0x70, + 0x0, 0x1, 0xef, 0xf5, 0xdf, 0xfa, 0x0, 0x0, + 0x0, 0x7f, 0xf8, 0xdf, 0xf4, 0x0, 0x0, 0x0, + 0x4f, 0xf9, 0xdf, 0xf1, 0x0, 0x0, 0x0, 0x2f, + 0xfa, 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xfa, + 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xfa, 0xdf, + 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xfa, 0xdf, 0xf0, + 0x0, 0x0, 0x0, 0x2f, 0xfa, 0xdf, 0xf0, 0x0, + 0x0, 0x0, 0x2f, 0xfa, 0xdf, 0xf0, 0x0, 0x0, + 0x0, 0x2f, 0xfa, 0xdf, 0xf0, 0x0, 0x0, 0x0, + 0x2f, 0xfa, 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x2f, + 0xfa, 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xfa, + 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xfa, + + /* U+006F "o" */ + 0x0, 0x0, 0x4a, 0xdf, 0xfd, 0x93, 0x0, 0x0, + 0x0, 0x1b, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x1, 0xef, 0xfe, 0x85, 0x69, 0xff, 0xfb, 0x0, + 0xb, 0xff, 0xc1, 0x0, 0x0, 0x2e, 0xff, 0x70, + 0x3f, 0xfe, 0x10, 0x0, 0x0, 0x3, 0xff, 0xe0, + 0x8f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf4, + 0xbf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf8, + 0xcf, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf9, + 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfa, + 0xcf, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf9, + 0xbf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf7, + 0x8f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf4, + 0x3f, 0xfe, 0x10, 0x0, 0x0, 0x3, 0xff, 0xe0, + 0xb, 0xff, 0xb1, 0x0, 0x0, 0x2d, 0xff, 0x70, + 0x1, 0xef, 0xfe, 0x85, 0x59, 0xff, 0xfb, 0x0, + 0x0, 0x1c, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x4a, 0xef, 0xfd, 0x93, 0x0, 0x0, + + /* U+0070 "p" */ + 0xdf, 0xb0, 0x2a, 0xef, 0xeb, 0x50, 0x0, 0xd, + 0xfb, 0x5f, 0xff, 0xff, 0xff, 0xb0, 0x0, 0xdf, + 0xef, 0xfa, 0x43, 0x6d, 0xff, 0xc0, 0xd, 0xff, + 0xf6, 0x0, 0x0, 0xc, 0xff, 0x60, 0xdf, 0xfb, + 0x0, 0x0, 0x0, 0x2f, 0xfe, 0xd, 0xff, 0x30, + 0x0, 0x0, 0x0, 0xbf, 0xf3, 0xdf, 0xf0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0x6d, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xf8, 0xdf, 0xb0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0x8d, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xf7, 0xdf, 0xe0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0x5d, 0xff, 0x20, 0x0, 0x0, 0x0, + 0xcf, 0xf2, 0xdf, 0xf9, 0x0, 0x0, 0x0, 0x3f, + 0xfc, 0xd, 0xff, 0xf4, 0x0, 0x0, 0x2e, 0xff, + 0x40, 0xdf, 0xff, 0xfa, 0x65, 0x9f, 0xff, 0x90, + 0xd, 0xff, 0x6f, 0xff, 0xff, 0xff, 0x90, 0x0, + 0xdf, 0xf0, 0x3a, 0xef, 0xea, 0x30, 0x0, 0xd, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0071 "q" */ + 0x0, 0x0, 0x7c, 0xef, 0xd8, 0x10, 0xff, 0x90, + 0x2, 0xef, 0xff, 0xff, 0xfe, 0x2f, 0xf9, 0x1, + 0xef, 0xfb, 0x53, 0x6c, 0xfd, 0xff, 0x90, 0xbf, + 0xf9, 0x0, 0x0, 0xa, 0xff, 0xf9, 0x2f, 0xfd, + 0x0, 0x0, 0x0, 0xe, 0xff, 0x97, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x8f, 0xf9, 0xaf, 0xf3, 0x0, + 0x0, 0x0, 0x3, 0xff, 0x9c, 0xff, 0x10, 0x0, + 0x0, 0x0, 0xf, 0xf9, 0xcf, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0xff, 0x9b, 0xff, 0x20, 0x0, 0x0, + 0x0, 0xf, 0xf9, 0x9f, 0xf4, 0x0, 0x0, 0x0, + 0x2, 0xff, 0x95, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x5f, 0xf9, 0xf, 0xfe, 0x10, 0x0, 0x0, 0xc, + 0xff, 0x90, 0x8f, 0xfb, 0x0, 0x0, 0x9, 0xff, + 0xf9, 0x0, 0xcf, 0xfe, 0x75, 0x6c, 0xff, 0xff, + 0x90, 0x1, 0xbf, 0xff, 0xff, 0xfe, 0x7f, 0xf9, + 0x0, 0x0, 0x5b, 0xef, 0xd8, 0x14, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0x90, + + /* U+0072 "r" */ + 0xef, 0x90, 0x6d, 0xfd, 0x90, 0xef, 0x97, 0xff, + 0xff, 0xc0, 0xef, 0xcf, 0xff, 0xff, 0x70, 0xef, + 0xff, 0x60, 0x3, 0x10, 0xef, 0xf9, 0x0, 0x0, + 0x0, 0xef, 0xf3, 0x0, 0x0, 0x0, 0xef, 0xf0, + 0x0, 0x0, 0x0, 0xef, 0xe0, 0x0, 0x0, 0x0, + 0xef, 0xe0, 0x0, 0x0, 0x0, 0xef, 0xe0, 0x0, + 0x0, 0x0, 0xef, 0xe0, 0x0, 0x0, 0x0, 0xef, + 0xe0, 0x0, 0x0, 0x0, 0xef, 0xe0, 0x0, 0x0, + 0x0, 0xef, 0xe0, 0x0, 0x0, 0x0, 0xef, 0xe0, + 0x0, 0x0, 0x0, 0xef, 0xe0, 0x0, 0x0, 0x0, + 0xef, 0xe0, 0x0, 0x0, 0x0, + + /* U+0073 "s" */ + 0x0, 0x0, 0x7c, 0xef, 0xec, 0x82, 0x0, 0x0, + 0x3, 0xef, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0xef, 0xfb, 0x75, 0x69, 0xff, 0xf6, 0x0, 0x5f, + 0xf8, 0x0, 0x0, 0x4, 0xff, 0xd0, 0x8, 0xff, + 0x30, 0x0, 0x0, 0xb, 0xca, 0x0, 0x6f, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xa5, 0x10, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xc8, 0x30, 0x0, 0x0, 0x2, 0xaf, 0xff, + 0xff, 0xff, 0xc2, 0x0, 0x0, 0x0, 0x4, 0x8c, + 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x6e, 0xff, 0x80, 0x57, 0x80, 0x0, 0x0, 0x0, + 0x4f, 0xfb, 0xd, 0xff, 0x20, 0x0, 0x0, 0x3, + 0xff, 0xb0, 0x7f, 0xfc, 0x0, 0x0, 0x0, 0xbf, + 0xf7, 0x0, 0xdf, 0xfe, 0x86, 0x57, 0xdf, 0xfd, + 0x0, 0x2, 0xdf, 0xff, 0xff, 0xff, 0xfc, 0x10, + 0x0, 0x0, 0x5b, 0xef, 0xfe, 0xb5, 0x0, 0x0, + + /* U+0074 "t" */ + 0x0, 0x0, 0x44, 0x0, 0x0, 0x1, 0xaf, 0x60, + 0x0, 0x0, 0x6f, 0xf6, 0x0, 0x0, 0x6, 0xff, + 0x60, 0x0, 0x0, 0x6f, 0xf6, 0x0, 0x0, 0x6, + 0xff, 0x60, 0x0, 0x7f, 0xff, 0xff, 0xff, 0x37, + 0xff, 0xff, 0xff, 0xf3, 0x13, 0x8f, 0xf7, 0x33, + 0x0, 0x6, 0xff, 0x60, 0x0, 0x0, 0x6f, 0xf6, + 0x0, 0x0, 0x6, 0xff, 0x60, 0x0, 0x0, 0x6f, + 0xf6, 0x0, 0x0, 0x6, 0xff, 0x60, 0x0, 0x0, + 0x6f, 0xf6, 0x0, 0x0, 0x6, 0xff, 0x60, 0x0, + 0x0, 0x6f, 0xf6, 0x0, 0x0, 0x6, 0xff, 0x60, + 0x0, 0x0, 0x6f, 0xf6, 0x0, 0x0, 0x5, 0xff, + 0x80, 0x0, 0x0, 0x4f, 0xff, 0xba, 0x30, 0x0, + 0xdf, 0xff, 0xf6, 0x0, 0x2, 0xae, 0xfe, 0x60, + + /* U+0075 "u" */ + 0xef, 0xe0, 0x0, 0x0, 0x0, 0x4f, 0xf9, 0xef, + 0xe0, 0x0, 0x0, 0x0, 0x4f, 0xf9, 0xef, 0xe0, + 0x0, 0x0, 0x0, 0x4f, 0xf9, 0xef, 0xe0, 0x0, + 0x0, 0x0, 0x4f, 0xf9, 0xef, 0xe0, 0x0, 0x0, + 0x0, 0x4f, 0xf9, 0xef, 0xe0, 0x0, 0x0, 0x0, + 0x4f, 0xf9, 0xef, 0xe0, 0x0, 0x0, 0x0, 0x4f, + 0xf9, 0xef, 0xe0, 0x0, 0x0, 0x0, 0x4f, 0xf9, + 0xef, 0xe0, 0x0, 0x0, 0x0, 0x4f, 0xf9, 0xef, + 0xe0, 0x0, 0x0, 0x0, 0x4f, 0xf9, 0xef, 0xf0, + 0x0, 0x0, 0x0, 0x5f, 0xf9, 0xdf, 0xf0, 0x0, + 0x0, 0x0, 0x8f, 0xf9, 0xcf, 0xf3, 0x0, 0x0, + 0x0, 0xef, 0xf9, 0x8f, 0xfc, 0x0, 0x0, 0xa, + 0xff, 0xf9, 0x2f, 0xff, 0xe8, 0x78, 0xef, 0xcf, + 0xf9, 0x5, 0xff, 0xff, 0xff, 0xfc, 0x1f, 0xf9, + 0x0, 0x29, 0xdf, 0xec, 0x60, 0xf, 0xf9, + + /* U+0076 "v" */ + 0x6f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf7, + 0x1f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf1, + 0xa, 0xff, 0x30, 0x0, 0x0, 0x2, 0xff, 0xb0, + 0x4, 0xff, 0x90, 0x0, 0x0, 0x8, 0xff, 0x50, + 0x0, 0xef, 0xe0, 0x0, 0x0, 0xd, 0xfe, 0x0, + 0x0, 0x8f, 0xf4, 0x0, 0x0, 0x3f, 0xf9, 0x0, + 0x0, 0x2f, 0xfa, 0x0, 0x0, 0x9f, 0xf3, 0x0, + 0x0, 0xc, 0xff, 0x0, 0x0, 0xef, 0xd0, 0x0, + 0x0, 0x7, 0xff, 0x50, 0x4, 0xff, 0x70, 0x0, + 0x0, 0x1, 0xff, 0xb0, 0xa, 0xff, 0x10, 0x0, + 0x0, 0x0, 0xbf, 0xf0, 0xf, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xf5, 0x5f, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xfa, 0xaf, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xf8, 0x0, 0x0, 0x0, + + /* U+0077 "w" */ + 0xbf, 0xf3, 0x0, 0x0, 0x0, 0xef, 0xf3, 0x0, + 0x0, 0x0, 0xff, 0xc6, 0xff, 0x70, 0x0, 0x0, + 0x3f, 0xff, 0x70, 0x0, 0x0, 0x4f, 0xf7, 0x1f, + 0xfb, 0x0, 0x0, 0x7, 0xff, 0xfb, 0x0, 0x0, + 0x8, 0xff, 0x20, 0xcf, 0xf0, 0x0, 0x0, 0xbf, + 0xff, 0xf0, 0x0, 0x0, 0xdf, 0xd0, 0x8, 0xff, + 0x40, 0x0, 0xf, 0xfb, 0xff, 0x30, 0x0, 0x1f, + 0xf8, 0x0, 0x3f, 0xf8, 0x0, 0x4, 0xff, 0x3f, + 0xf7, 0x0, 0x6, 0xff, 0x30, 0x0, 0xef, 0xc0, + 0x0, 0x8f, 0xd0, 0xef, 0xb0, 0x0, 0xbf, 0xe0, + 0x0, 0x9, 0xff, 0x10, 0xc, 0xf9, 0xa, 0xff, + 0x0, 0xf, 0xfa, 0x0, 0x0, 0x4f, 0xf5, 0x1, + 0xff, 0x50, 0x6f, 0xf3, 0x4, 0xff, 0x50, 0x0, + 0x0, 0xff, 0x90, 0x5f, 0xf1, 0x2, 0xff, 0x70, + 0x9f, 0xf0, 0x0, 0x0, 0xb, 0xfe, 0x9, 0xfd, + 0x0, 0xe, 0xfb, 0xd, 0xfb, 0x0, 0x0, 0x0, + 0x6f, 0xf2, 0xdf, 0x90, 0x0, 0x9f, 0xf2, 0xff, + 0x60, 0x0, 0x0, 0x1, 0xff, 0x8f, 0xf5, 0x0, + 0x5, 0xff, 0xaf, 0xf1, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0x10, 0x0, 0x1f, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xd0, 0x0, 0x0, + 0xdf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf8, 0x0, 0x0, 0x9, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0x40, 0x0, 0x0, 0x5f, + 0xfe, 0x0, 0x0, 0x0, + + /* U+0078 "x" */ + 0x1e, 0xff, 0x80, 0x0, 0x0, 0x6, 0xff, 0xe1, + 0x4, 0xff, 0xf2, 0x0, 0x0, 0x2f, 0xff, 0x40, + 0x0, 0x9f, 0xfc, 0x0, 0x0, 0xcf, 0xf8, 0x0, + 0x0, 0xd, 0xff, 0x70, 0x7, 0xff, 0xc0, 0x0, + 0x0, 0x3, 0xff, 0xf1, 0x2f, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x8f, 0xfb, 0xcf, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xfd, 0xdf, 0xf4, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xf3, 0x3f, 0xfe, 0x10, 0x0, + 0x0, 0xa, 0xff, 0x90, 0x9, 0xff, 0xa0, 0x0, + 0x0, 0x5f, 0xfd, 0x0, 0x0, 0xef, 0xf5, 0x0, + 0x1, 0xff, 0xf4, 0x0, 0x0, 0x4f, 0xff, 0x10, + 0xb, 0xff, 0x90, 0x0, 0x0, 0xa, 0xff, 0xb0, + 0x6f, 0xfe, 0x10, 0x0, 0x0, 0x1, 0xef, 0xf6, + + /* U+0079 "y" */ + 0x4f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf8, + 0xe, 0xff, 0x10, 0x0, 0x0, 0x0, 0xaf, 0xf2, + 0x8, 0xff, 0x70, 0x0, 0x0, 0x0, 0xff, 0xc0, + 0x2, 0xff, 0xd0, 0x0, 0x0, 0x6, 0xff, 0x60, + 0x0, 0xcf, 0xf3, 0x0, 0x0, 0xc, 0xff, 0x0, + 0x0, 0x5f, 0xf8, 0x0, 0x0, 0x2f, 0xfa, 0x0, + 0x0, 0xf, 0xfe, 0x0, 0x0, 0x8f, 0xf4, 0x0, + 0x0, 0x9, 0xff, 0x40, 0x0, 0xef, 0xd0, 0x0, + 0x0, 0x3, 0xff, 0xa0, 0x4, 0xff, 0x70, 0x0, + 0x0, 0x0, 0xdf, 0xf0, 0xa, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x7f, 0xf5, 0xe, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xfa, 0x4f, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0x9f, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x4, 0xdc, 0xef, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xea, 0x20, 0x0, 0x0, 0x0, 0x0, + + /* U+007A "z" */ + 0xc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, + 0xc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, + 0x2, 0x33, 0x33, 0x33, 0x33, 0x5f, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1d, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x95, 0x66, 0x66, 0x66, 0x66, 0x62, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + + /* U+007B "{" */ + 0x0, 0x0, 0x1, 0x9d, 0xff, 0x0, 0x0, 0xe, + 0xff, 0xff, 0x0, 0x0, 0x7f, 0xfe, 0x97, 0x0, + 0x0, 0xaf, 0xf1, 0x0, 0x0, 0x0, 0xcf, 0xd0, + 0x0, 0x0, 0x0, 0xdf, 0xc0, 0x0, 0x0, 0x0, + 0xdf, 0xc0, 0x0, 0x0, 0x0, 0xef, 0xc0, 0x0, + 0x0, 0x0, 0xef, 0xb0, 0x0, 0x0, 0x0, 0xff, + 0xa0, 0x0, 0x0, 0x3, 0xff, 0x70, 0x0, 0x0, + 0xb, 0xff, 0x20, 0x0, 0xa, 0xef, 0xf5, 0x0, + 0x0, 0x1f, 0xfd, 0x20, 0x0, 0x0, 0x1f, 0xff, + 0xb0, 0x0, 0x0, 0x1, 0x6f, 0xfa, 0x0, 0x0, + 0x0, 0x7, 0xff, 0x30, 0x0, 0x0, 0x2, 0xff, + 0x70, 0x0, 0x0, 0x0, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0xef, 0xb0, 0x0, 0x0, 0x0, 0xef, 0xc0, + 0x0, 0x0, 0x0, 0xdf, 0xc0, 0x0, 0x0, 0x0, + 0xdf, 0xc0, 0x0, 0x0, 0x0, 0xcf, 0xc0, 0x0, + 0x0, 0x0, 0xbf, 0xd0, 0x0, 0x0, 0x0, 0xaf, + 0xf1, 0x0, 0x0, 0x0, 0x5f, 0xfd, 0x87, 0x0, + 0x0, 0xc, 0xff, 0xff, 0x0, 0x0, 0x0, 0x9e, + 0xff, + + /* U+007C "|" */ + 0x1f, 0xf6, 0x1f, 0xf6, 0x1f, 0xf6, 0x1f, 0xf6, + 0x1f, 0xf6, 0x1f, 0xf6, 0x1f, 0xf6, 0x1f, 0xf6, + 0x1f, 0xf6, 0x1f, 0xf6, 0x1f, 0xf6, 0x1f, 0xf6, + 0x1f, 0xf6, 0x1f, 0xf6, 0x1f, 0xf6, 0x1f, 0xf6, + 0x1f, 0xf6, 0x1f, 0xf6, 0x1f, 0xf6, 0x1f, 0xf6, + 0x1f, 0xf6, 0x1f, 0xf6, 0x1f, 0xf6, 0x1f, 0xf6, + 0x1f, 0xf6, 0x1f, 0xf6, 0x1f, 0xf6, 0x1f, 0xf6, + 0x1f, 0xf6, + + /* U+007D "}" */ + 0x4f, 0xfd, 0x70, 0x0, 0x0, 0x4f, 0xff, 0xf9, + 0x0, 0x0, 0x17, 0x9f, 0xff, 0x20, 0x0, 0x0, + 0x5, 0xff, 0x50, 0x0, 0x0, 0x2, 0xff, 0x70, + 0x0, 0x0, 0x1, 0xff, 0x80, 0x0, 0x0, 0x1, + 0xff, 0x80, 0x0, 0x0, 0x1, 0xff, 0x80, 0x0, + 0x0, 0x0, 0xff, 0x90, 0x0, 0x0, 0x0, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0xcf, 0xe0, 0x0, 0x0, + 0x0, 0x6f, 0xf7, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xc7, 0x0, 0x0, 0x0, 0x6f, 0xfc, 0x0, 0x0, + 0x3, 0xdf, 0xfc, 0x0, 0x0, 0x1e, 0xfd, 0x30, + 0x0, 0x0, 0x8f, 0xf2, 0x0, 0x0, 0x0, 0xdf, + 0xd0, 0x0, 0x0, 0x0, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0xff, 0x90, 0x0, 0x0, 0x1, 0xff, 0x80, + 0x0, 0x0, 0x1, 0xff, 0x80, 0x0, 0x0, 0x1, + 0xff, 0x80, 0x0, 0x0, 0x1, 0xff, 0x70, 0x0, + 0x0, 0x2, 0xff, 0x60, 0x0, 0x0, 0x6, 0xff, + 0x40, 0x0, 0x17, 0xaf, 0xff, 0x10, 0x0, 0x4f, + 0xff, 0xf7, 0x0, 0x0, 0x4f, 0xec, 0x50, 0x0, + 0x0, + + /* U+007E "~" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x29, 0xdf, 0xeb, 0x71, 0x0, 0x0, 0x0, + 0x44, 0x4f, 0xff, 0xff, 0xff, 0xfb, 0x51, 0x2, + 0x9f, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf5, 0xaf, 0x71, 0x2, 0x6c, 0xff, 0xff, + 0xff, 0xfd, 0x27, 0x20, 0x0, 0x0, 0x2, 0x8c, + 0xef, 0xc7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+00A0 " " */ + + /* U+00A3 "£" */ + 0x0, 0x0, 0x1, 0x7c, 0xef, 0xeb, 0x60, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xd3, + 0x0, 0x0, 0x6, 0xff, 0xfb, 0x65, 0x7d, 0xff, + 0xf2, 0x0, 0x1, 0xff, 0xf6, 0x0, 0x0, 0xb, + 0xff, 0xb0, 0x0, 0x6f, 0xfa, 0x0, 0x0, 0x0, + 0xe, 0xff, 0x10, 0x9, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x9e, 0xc3, 0x0, 0x9f, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x15, 0x56, + 0xff, 0xe5, 0x55, 0x50, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xe2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xfd, 0xef, 0xeb, 0x73, 0x0, + 0x0, 0x72, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0xbb, 0xff, 0x81, 0xff, 0xe9, 0x65, 0x7b, 0xff, + 0xff, 0xff, 0xfd, 0x9, 0x60, 0x0, 0x0, 0x1, + 0x6b, 0xef, 0xc7, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+00A4 "¤" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0x80, 0x0, 0x0, 0x0, 0x0, 0xb, 0x50, + 0x7f, 0xf8, 0x18, 0xdf, 0xfc, 0x71, 0xbf, 0xf4, + 0x2e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc1, + 0x2, 0xef, 0xff, 0xc9, 0xae, 0xff, 0xfc, 0x0, + 0x0, 0xef, 0xf5, 0x0, 0x0, 0x8f, 0xfb, 0x0, + 0x6, 0xff, 0x60, 0x0, 0x0, 0xa, 0xff, 0x20, + 0xa, 0xff, 0x0, 0x0, 0x0, 0x3, 0xff, 0x60, + 0xb, 0xfd, 0x0, 0x0, 0x0, 0x1, 0xff, 0x70, + 0x9, 0xff, 0x0, 0x0, 0x0, 0x3, 0xff, 0x60, + 0x5, 0xff, 0x60, 0x0, 0x0, 0xa, 0xff, 0x20, + 0x0, 0xef, 0xf5, 0x0, 0x0, 0x8f, 0xfb, 0x0, + 0x2, 0xef, 0xff, 0xc9, 0xae, 0xff, 0xfc, 0x0, + 0x2e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc1, + 0x7f, 0xf8, 0x18, 0xdf, 0xfc, 0x71, 0xbf, 0xf4, + 0x8, 0x90, 0x0, 0x0, 0x0, 0x0, 0xb, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00A5 "¥" */ + 0xbf, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xf7, 0x2f, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xd0, 0x8, 0xff, 0x80, 0x0, 0x0, 0x0, + 0xe, 0xff, 0x50, 0x0, 0xef, 0xf2, 0x0, 0x0, + 0x0, 0x7f, 0xfb, 0x0, 0x0, 0x6f, 0xfb, 0x0, + 0x0, 0x1, 0xff, 0xf2, 0x0, 0x0, 0xc, 0xff, + 0x40, 0x0, 0x9, 0xff, 0x90, 0x0, 0x0, 0x3, + 0xff, 0xd0, 0x0, 0x2f, 0xff, 0x10, 0x0, 0x0, + 0x0, 0xaf, 0xf6, 0x0, 0xaf, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xfe, 0x3, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0x7b, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc0, 0xf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc0, 0x4, 0x55, 0x55, + 0x5a, 0xff, 0x85, 0x55, 0x55, 0x30, 0x0, 0x0, + 0x0, 0x7, 0xff, 0x50, 0x0, 0x0, 0x0, 0x2, + 0x22, 0x22, 0x29, 0xff, 0x72, 0x22, 0x22, 0x20, + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xc0, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0x50, 0x0, 0x0, 0x0, + + /* U+00A6 "¦" */ + 0x1f, 0xf6, 0x1f, 0xf6, 0x1f, 0xf6, 0x1f, 0xf6, + 0x1f, 0xf6, 0x1f, 0xf6, 0x1f, 0xf6, 0x1f, 0xf6, + 0x1f, 0xf6, 0x1f, 0xf6, 0x1f, 0xf6, 0x1f, 0xf6, + 0x6, 0x62, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0x62, 0x1f, 0xf6, 0x1f, 0xf6, 0x1f, 0xf6, + 0x1f, 0xf6, 0x1f, 0xf6, 0x1f, 0xf6, 0x1f, 0xf6, + 0x1f, 0xf6, 0x1f, 0xf6, 0x1f, 0xf6, 0x1f, 0xf6, + 0x1f, 0xf6, + + /* U+00A7 "§" */ + 0x0, 0x0, 0x4b, 0xef, 0xfc, 0x81, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x7f, 0xff, 0x96, 0x7c, 0xff, 0xf2, 0x0, + 0x0, 0xef, 0xe2, 0x0, 0x0, 0xbf, 0xf9, 0x0, + 0x2, 0xff, 0xa0, 0x0, 0x0, 0x2f, 0xfe, 0x0, + 0x1, 0xff, 0xc0, 0x0, 0x0, 0x8, 0x75, 0x0, + 0x0, 0xcf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xb1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x1, 0xcf, 0xfd, 0xff, 0xfc, 0x30, 0x0, 0x0, + 0xd, 0xfd, 0x20, 0x8f, 0xff, 0xf9, 0x0, 0x0, + 0x6f, 0xf3, 0x0, 0x3, 0xcf, 0xff, 0xd3, 0x0, + 0x9f, 0xe0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x30, + 0x9f, 0xf1, 0x0, 0x0, 0x0, 0x3e, 0xff, 0xe0, + 0x5f, 0xf9, 0x0, 0x0, 0x0, 0x1, 0xef, 0xf4, + 0xc, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x7f, 0xf5, + 0x1, 0xcf, 0xfd, 0x40, 0x0, 0x0, 0x5f, 0xf3, + 0x0, 0x9, 0xff, 0xfa, 0x10, 0x0, 0xaf, 0xd0, + 0x0, 0x0, 0x4d, 0xff, 0xf6, 0x8, 0xfd, 0x20, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xef, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xbf, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x0, + 0x5, 0xac, 0x30, 0x0, 0x0, 0x9, 0xff, 0x40, + 0x7, 0xff, 0x90, 0x0, 0x0, 0x9, 0xff, 0x40, + 0x2, 0xff, 0xf4, 0x0, 0x0, 0x3f, 0xff, 0x10, + 0x0, 0x9f, 0xff, 0xb7, 0x69, 0xff, 0xf8, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x39, 0xdf, 0xfe, 0xa4, 0x0, 0x0, + + /* U+00A8 "¨" */ + 0x3, 0x33, 0x0, 0x3, 0x32, 0xf, 0xfe, 0x0, + 0x3f, 0xfb, 0xf, 0xfe, 0x0, 0x3f, 0xfb, 0xf, + 0xfe, 0x0, 0x3f, 0xfb, + + /* U+00A9 "©" */ + 0x0, 0x0, 0x0, 0x1, 0x7b, 0xde, 0xec, 0x95, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xe6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x94, 0x20, 0x2, 0x6c, + 0xff, 0xc1, 0x0, 0x0, 0x0, 0x7, 0xff, 0x91, + 0x0, 0x0, 0x0, 0x0, 0x4d, 0xfd, 0x20, 0x0, + 0x0, 0x5f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xd0, 0x0, 0x1, 0xff, 0x60, 0x0, + 0x5, 0x9b, 0xb8, 0x30, 0x0, 0xc, 0xfa, 0x0, + 0xa, 0xf9, 0x0, 0x2, 0xdf, 0xff, 0xff, 0xf9, + 0x0, 0x1, 0xef, 0x30, 0x1f, 0xf1, 0x0, 0x1e, + 0xfc, 0x30, 0x15, 0xef, 0x80, 0x0, 0x7f, 0xb0, + 0x7f, 0x90, 0x0, 0x9f, 0xc0, 0x0, 0x0, 0x2f, + 0xf1, 0x0, 0xf, 0xf0, 0xbf, 0x40, 0x0, 0xff, + 0x40, 0x0, 0x0, 0x4, 0x30, 0x0, 0xb, 0xf4, + 0xef, 0x10, 0x3, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xf6, 0xff, 0x0, 0x5, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xf8, + 0xff, 0x0, 0x5, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xf8, 0xdf, 0x10, 0x4, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xf7, + 0xbf, 0x40, 0x0, 0xff, 0x10, 0x0, 0x0, 0x8, + 0xa3, 0x0, 0xb, 0xf5, 0x7f, 0x90, 0x0, 0xaf, + 0x90, 0x0, 0x0, 0x2f, 0xf3, 0x0, 0xf, 0xf0, + 0x2f, 0xf1, 0x0, 0x2f, 0xf8, 0x0, 0x5, 0xef, + 0xb0, 0x0, 0x6f, 0xb0, 0xa, 0xf9, 0x0, 0x5, + 0xff, 0xfd, 0xff, 0xfc, 0x10, 0x1, 0xef, 0x30, + 0x2, 0xff, 0x50, 0x0, 0x29, 0xdf, 0xfc, 0x60, + 0x0, 0xb, 0xfa, 0x0, 0x0, 0x5f, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xd1, 0x0, + 0x0, 0x8, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x3c, 0xfe, 0x20, 0x0, 0x0, 0x0, 0x6f, 0xfe, + 0x83, 0x10, 0x1, 0x5a, 0xff, 0xc1, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0x7c, 0xef, 0xfd, 0xa5, 0x10, 0x0, 0x0, 0x0, + + /* U+00AA "ª" */ + 0x0, 0x2a, 0xef, 0xd6, 0xd, 0xf6, 0x2, 0xef, + 0xfc, 0xef, 0xaf, 0xf1, 0xc, 0xfd, 0x10, 0xb, + 0xff, 0xd0, 0x2f, 0xf5, 0x0, 0x3, 0xff, 0xa0, + 0x6f, 0xf0, 0x0, 0x0, 0xef, 0x70, 0x7f, 0xe0, + 0x0, 0x0, 0xcf, 0x40, 0x7f, 0xf0, 0x0, 0x0, + 0xcf, 0x40, 0x6f, 0xf0, 0x0, 0x0, 0xef, 0x70, + 0x2f, 0xf5, 0x0, 0x4, 0xff, 0xa0, 0xb, 0xfc, + 0x0, 0x1c, 0xff, 0xd0, 0x2, 0xef, 0xec, 0xff, + 0xaf, 0xf2, 0x0, 0x2a, 0xef, 0xd6, 0xd, 0xf6, + + /* U+00AB "«" */ + 0x0, 0x0, 0x4, 0x41, 0x0, 0x4, 0x42, 0x0, + 0x0, 0x6f, 0xe1, 0x0, 0x5f, 0xf2, 0x0, 0x2, + 0xff, 0x60, 0x1, 0xef, 0x80, 0x0, 0xc, 0xfd, + 0x0, 0xb, 0xfe, 0x0, 0x0, 0x8f, 0xf4, 0x0, + 0x6f, 0xf5, 0x0, 0x3, 0xff, 0xb0, 0x2, 0xff, + 0xc0, 0x0, 0xd, 0xff, 0x20, 0xc, 0xff, 0x30, + 0x0, 0x9f, 0xf9, 0x0, 0x7f, 0xfa, 0x0, 0x0, + 0x6f, 0xfb, 0x0, 0x4f, 0xfc, 0x0, 0x0, 0xb, + 0xff, 0x40, 0x9, 0xff, 0x50, 0x0, 0x1, 0xef, + 0xd0, 0x0, 0xdf, 0xe0, 0x0, 0x0, 0x4f, 0xf6, + 0x0, 0x3f, 0xf8, 0x0, 0x0, 0x9, 0xfe, 0x10, + 0x8, 0xff, 0x20, 0x0, 0x0, 0xdf, 0x90, 0x0, + 0xdf, 0xa0, 0x0, 0x0, 0x3f, 0xf2, 0x0, 0x3f, + 0xf4, + + /* U+00AC "¬" */ + 0x2a, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xa9, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfe, + + /* U+00AD "­" */ + 0xdd, 0xdd, 0xdd, 0xdd, 0x8f, 0xff, 0xff, 0xff, + 0xfa, 0xff, 0xff, 0xff, 0xff, 0xa0, + + /* U+00AE "®" */ + 0x0, 0x0, 0x0, 0x1, 0x7b, 0xde, 0xec, 0x95, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xe6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x94, 0x20, 0x2, 0x6c, + 0xff, 0xc1, 0x0, 0x0, 0x0, 0x7, 0xff, 0x91, + 0x0, 0x0, 0x0, 0x0, 0x4d, 0xfd, 0x20, 0x0, + 0x0, 0x5f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xd0, 0x0, 0x1, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfa, 0x0, + 0xa, 0xf9, 0x0, 0x6f, 0xff, 0xff, 0xec, 0x80, + 0x0, 0x1, 0xef, 0x30, 0x1f, 0xf1, 0x0, 0x6f, + 0xeb, 0xbb, 0xdf, 0xfb, 0x0, 0x0, 0x7f, 0xb0, + 0x7f, 0x90, 0x0, 0x6f, 0xa0, 0x0, 0x3, 0xff, + 0x40, 0x0, 0xf, 0xf0, 0xbf, 0x40, 0x0, 0x6f, + 0xa0, 0x0, 0x0, 0xdf, 0x50, 0x0, 0xb, 0xf4, + 0xef, 0x10, 0x0, 0x6f, 0xa0, 0x0, 0x4, 0xff, + 0x20, 0x0, 0x8, 0xf6, 0xff, 0x0, 0x0, 0x6f, + 0xec, 0xcc, 0xef, 0xf6, 0x0, 0x0, 0x6, 0xf8, + 0xff, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf9, 0x30, + 0x0, 0x0, 0x6, 0xf8, 0xdf, 0x10, 0x0, 0x6f, + 0xa0, 0x18, 0xfc, 0x10, 0x0, 0x0, 0x8, 0xf7, + 0xbf, 0x40, 0x0, 0x6f, 0xa0, 0x0, 0x9f, 0xb0, + 0x0, 0x0, 0xb, 0xf5, 0x7f, 0x90, 0x0, 0x6f, + 0xa0, 0x0, 0xe, 0xf6, 0x0, 0x0, 0xf, 0xf0, + 0x2f, 0xf1, 0x0, 0x6f, 0xa0, 0x0, 0x5, 0xfe, + 0x10, 0x0, 0x6f, 0xb0, 0xa, 0xf9, 0x0, 0x6f, + 0xa0, 0x0, 0x0, 0xcf, 0x90, 0x1, 0xef, 0x30, + 0x2, 0xff, 0x50, 0x39, 0x60, 0x0, 0x0, 0x39, + 0x91, 0xb, 0xfa, 0x0, 0x0, 0x5f, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xd1, 0x0, + 0x0, 0x8, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x3c, 0xfe, 0x20, 0x0, 0x0, 0x0, 0x6f, 0xfe, + 0x83, 0x10, 0x1, 0x5a, 0xff, 0xc1, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0x7c, 0xef, 0xfd, 0xa5, 0x10, 0x0, 0x0, 0x0, + + /* U+00B0 "°" */ + 0x0, 0x39, 0xa8, 0x20, 0x0, 0x8f, 0xff, 0xff, + 0x50, 0x5f, 0xd3, 0x4, 0xef, 0x2c, 0xf1, 0x0, + 0x4, 0xf8, 0xed, 0x0, 0x0, 0xf, 0xbd, 0xe0, + 0x0, 0x2, 0xfa, 0x8f, 0x90, 0x1, 0xcf, 0x40, + 0xcf, 0xec, 0xef, 0xa0, 0x0, 0x8e, 0xfd, 0x60, + 0x0, + + /* U+00B1 "±" */ + 0x0, 0x0, 0x0, 0x2, 0x21, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x2a, 0xaa, 0xaa, 0xaf, 0xfe, 0xaa, 0xaa, 0xa9, + 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2a, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xa9, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + + /* U+00B2 "²" */ + 0x0, 0x3b, 0xef, 0xeb, 0x50, 0x0, 0x5f, 0xff, + 0xdf, 0xff, 0x70, 0xe, 0xfa, 0x0, 0x1c, 0xfe, + 0x1, 0x8a, 0x20, 0x0, 0x7f, 0xf0, 0x0, 0x0, + 0x0, 0xb, 0xfc, 0x0, 0x0, 0x0, 0x9, 0xff, + 0x40, 0x0, 0x0, 0x1b, 0xff, 0x60, 0x0, 0x0, + 0x3e, 0xff, 0x50, 0x0, 0x0, 0x5f, 0xfd, 0x20, + 0x0, 0x0, 0x5f, 0xfb, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xee, 0xee, 0xee, 0x17, 0xff, 0xff, 0xff, + 0xff, 0xf1, + + /* U+00B3 "³" */ + 0x0, 0x5c, 0xef, 0xea, 0x20, 0x0, 0x6f, 0xfd, + 0xcf, 0xff, 0x20, 0xe, 0xf9, 0x0, 0x2f, 0xf7, + 0x0, 0x36, 0x0, 0x0, 0xff, 0x70, 0x0, 0x0, + 0x1, 0x8f, 0xf2, 0x0, 0x0, 0x7, 0xff, 0xd2, + 0x0, 0x0, 0x0, 0x6b, 0xef, 0xd3, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xd0, 0x14, 0x50, 0x0, 0x6, + 0xff, 0x3, 0xff, 0x60, 0x2, 0xdf, 0xe0, 0x9, + 0xff, 0xed, 0xff, 0xf5, 0x0, 0x6, 0xce, 0xfd, + 0xa2, 0x0, + + /* U+00B5 "µ" */ + 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xf9, 0xdf, + 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xf9, 0xdf, 0xf0, + 0x0, 0x0, 0x0, 0x2f, 0xf9, 0xdf, 0xf0, 0x0, + 0x0, 0x0, 0x2f, 0xf9, 0xdf, 0xf0, 0x0, 0x0, + 0x0, 0x2f, 0xf9, 0xdf, 0xf0, 0x0, 0x0, 0x0, + 0x2f, 0xf9, 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x2f, + 0xf9, 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xf9, + 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x3f, 0xf9, 0xdf, + 0xf0, 0x0, 0x0, 0x0, 0x3f, 0xf9, 0xdf, 0xf1, + 0x0, 0x0, 0x0, 0x4f, 0xf9, 0xdf, 0xf4, 0x0, + 0x0, 0x0, 0x7f, 0xf9, 0xdf, 0xfa, 0x0, 0x0, + 0x0, 0xdf, 0xf9, 0xdf, 0xff, 0x60, 0x0, 0xa, + 0xff, 0xf9, 0xdf, 0xff, 0xfd, 0x9a, 0xef, 0xff, + 0xf9, 0xdf, 0xf9, 0xff, 0xff, 0xff, 0x6e, 0xf9, + 0xdf, 0xf0, 0x5c, 0xfe, 0xb4, 0xe, 0xf9, 0xdf, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+00B6 "¶" */ + 0x0, 0x0, 0x4a, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x30, 0x1, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf3, 0x0, 0xcf, 0xff, 0xff, 0xff, + 0xbb, 0xbe, 0xff, 0xbb, 0x20, 0x6f, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0xbf, 0xf0, 0x0, 0xc, 0xff, + 0xff, 0xff, 0xfd, 0x0, 0xb, 0xff, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0, 0xbf, 0xf0, + 0x0, 0xf, 0xff, 0xff, 0xff, 0xfd, 0x0, 0xb, + 0xff, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xd0, + 0x0, 0xbf, 0xf0, 0x0, 0xc, 0xff, 0xff, 0xff, + 0xfd, 0x0, 0xb, 0xff, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0xbf, 0xf0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xfd, 0x0, 0xb, 0xff, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xd0, 0x0, 0xbf, + 0xf0, 0x0, 0x0, 0x0, 0x39, 0xbf, 0xfd, 0x0, + 0xb, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xd0, 0x0, 0xbf, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xfd, 0x0, 0xb, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xd0, 0x0, 0xbf, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xfd, 0x0, 0xb, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xd0, 0x0, + 0xbf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfd, + 0x0, 0xb, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xd0, 0x0, 0xbf, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xfd, 0x0, 0xb, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xd0, 0x0, 0xbf, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xfd, 0x0, 0xb, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xd0, + 0x0, 0xbf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xfd, 0x0, 0xb, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xd0, 0x0, 0xbf, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xfd, 0x0, 0xb, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xd0, 0x0, 0xbf, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfd, 0x0, + 0xb, 0xff, 0x0, 0x0, + + /* U+00B7 "·" */ + 0x3, 0x33, 0x2, 0xff, 0xf1, 0x2f, 0xff, 0x12, + 0xff, 0xf1, + + /* U+00BB "»" */ + 0x34, 0x30, 0x0, 0x24, 0x30, 0x0, 0x0, 0x4f, + 0xf2, 0x0, 0x3f, 0xf3, 0x0, 0x0, 0xb, 0xfc, + 0x0, 0xa, 0xfd, 0x0, 0x0, 0x2, 0xff, 0x80, + 0x1, 0xff, 0x90, 0x0, 0x0, 0x9f, 0xf3, 0x0, + 0x8f, 0xf4, 0x0, 0x0, 0x1e, 0xfd, 0x0, 0xe, + 0xfe, 0x10, 0x0, 0x6, 0xff, 0x90, 0x5, 0xff, + 0xb0, 0x0, 0x0, 0xdf, 0xf4, 0x0, 0xcf, 0xf6, + 0x0, 0x1, 0xef, 0xf2, 0x0, 0xef, 0xf3, 0x0, + 0x9, 0xff, 0x60, 0x8, 0xff, 0x70, 0x0, 0x2f, + 0xfb, 0x0, 0x1f, 0xfc, 0x0, 0x0, 0xbf, 0xe1, + 0x0, 0xaf, 0xf2, 0x0, 0x4, 0xff, 0x50, 0x3, + 0xff, 0x60, 0x0, 0xd, 0xfa, 0x0, 0xc, 0xfb, + 0x0, 0x0, 0x7f, 0xe1, 0x0, 0x5f, 0xe1, 0x0, + 0x0, + + /* U+00BD "½" */ + 0x0, 0x0, 0x8e, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xec, 0x0, 0x0, 0x0, 0x9, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf4, + 0x0, 0x0, 0x3, 0xcf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0x80, 0x0, 0x0, 0x4f, + 0xfc, 0xef, 0x70, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xfc, 0x0, 0x0, 0x0, 0x5c, 0x50, 0xdf, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0x70, 0x0, 0x0, 0x0, + 0x1, 0xef, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0x70, 0x0, 0x0, 0x0, 0xb, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0x70, 0x0, + 0x0, 0x0, 0x7f, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0x70, 0x0, 0x0, 0x2, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0x70, 0x0, 0x0, 0xd, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0x70, 0x0, 0x0, + 0x8f, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0x70, 0x0, 0x4, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xf7, 0x0, 0x1, 0x8b, 0xdc, 0x93, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xc0, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0x20, 0x0, 0xdf, 0xc2, + 0x3, 0xdf, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xf5, 0x0, 0x1, 0xab, 0x30, 0x0, 0x7f, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xd0, 0x0, 0x0, 0x0, + 0x7, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x3f, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x2d, 0xff, 0x60, 0x0, 0x0, 0x0, 0x9, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xd3, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xfb, 0x10, 0x0, 0x0, 0x0, 0x1, + 0xef, 0x60, 0x0, 0x0, 0x0, 0x1, 0xef, 0xfe, + 0xee, 0xee, 0xe1, 0x0, 0xb, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xf2, + 0x0, 0x28, 0x81, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0384 "΄" */ + 0x0, 0x36, 0x66, 0x0, 0xd, 0xff, 0x80, 0x5, + 0xff, 0xb0, 0x0, 0xdf, 0xe1, 0x0, 0x4f, 0xf3, + 0x0, 0x0, + + /* U+0386 "Ά" */ + 0x0, 0x5, 0xff, 0xf3, 0x6, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf6, 0x0, + 0xcf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xfa, 0x0, 0x2f, 0xfe, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xfd, 0x0, 0x8, 0xff, + 0x6f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x66, + 0x20, 0x0, 0xef, 0xd0, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf8, 0xa, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0x30, 0x4f, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xd0, 0x0, 0xef, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xf7, 0x0, 0x8, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0x10, 0x0, 0x2f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xb0, + 0x0, 0x0, 0xcf, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xf5, 0x0, 0x0, 0x6, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xd7, 0x77, 0x77, 0x77, 0xdf, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x8, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xfc, 0x0, 0x0, 0x0, 0xef, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf2, 0x0, 0x0, + 0x4f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0x90, 0x0, 0xa, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x0, 0x1, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf6, 0x0, 0x7f, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xc0, 0xd, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0x30, + + /* U+0388 "Έ" */ + 0x0, 0x8f, 0xfe, 0x10, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd0, 0x1, 0xff, 0xf3, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd0, 0x7, 0xff, 0x60, 0x0, 0xbf, 0xfc, + 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0x90, 0xe, + 0xfa, 0x0, 0x0, 0xbf, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x16, 0x60, 0x0, 0x0, + 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xfc, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xba, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xfc, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, + 0xb4, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf5, + + /* U+0389 "Ή" */ + 0x0, 0x8f, 0xfe, 0x16, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xf9, 0x1, 0xff, 0xf3, + 0x6, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xf9, 0x7, 0xff, 0x60, 0x6, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, 0xe, + 0xfa, 0x0, 0x6, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf9, 0x16, 0x60, 0x0, 0x6, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xf9, 0x0, 0x0, 0x0, 0x6, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xeb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, + 0xdf, 0xf9, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xf9, 0x0, 0x0, 0x0, 0x6, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x6, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xf9, 0x0, 0x0, 0x0, 0x6, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xf9, + + /* U+038A "Ί" */ + 0x0, 0x8f, 0xfe, 0x16, 0xff, 0xa0, 0x1f, 0xff, + 0x30, 0x6f, 0xfa, 0x7, 0xff, 0x60, 0x6, 0xff, + 0xa0, 0xef, 0xa0, 0x0, 0x6f, 0xfa, 0x16, 0x60, + 0x0, 0x6, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x6f, + 0xfa, 0x0, 0x0, 0x0, 0x6, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x6f, 0xfa, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x6f, 0xfa, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x6f, 0xfa, 0x0, 0x0, 0x0, 0x6, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x6f, 0xfa, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x6f, 0xfa, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x6f, 0xfa, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x6f, 0xfa, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x6f, + 0xfa, 0x0, 0x0, 0x0, 0x6, 0xff, 0xa0, + + /* U+038C "Ό" */ + 0x0, 0x8f, 0xfe, 0x10, 0x0, 0x5a, 0xde, 0xfe, + 0xc8, 0x40, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf3, + 0x0, 0x7e, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x30, + 0x0, 0x0, 0x7, 0xff, 0x60, 0x1b, 0xff, 0xff, + 0xdb, 0xab, 0xef, 0xff, 0xf6, 0x0, 0x0, 0xe, + 0xfa, 0x0, 0xcf, 0xff, 0x91, 0x0, 0x0, 0x4, + 0xcf, 0xff, 0x70, 0x0, 0x16, 0x60, 0xa, 0xff, + 0xe3, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xfd, 0x0, 0x0, 0x0, + 0xaf, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0x50, 0x0, 0x0, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xa0, + 0x0, 0x4, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xe0, 0x0, 0x7, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf1, 0x0, 0x8, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf3, 0x0, + 0x9, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf4, 0x0, 0x9, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xf3, 0x0, 0x7, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf1, 0x0, 0x4, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf0, 0x0, 0x0, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xb0, + 0x0, 0x0, 0xbf, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0x50, 0x0, 0x0, 0x3f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xfd, 0x0, 0x0, 0x0, 0xa, 0xff, 0xe3, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x81, 0x0, 0x0, 0x3, + 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x1b, + 0xff, 0xff, 0xca, 0x9b, 0xef, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7e, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6a, 0xdf, 0xfe, 0xc8, 0x40, + 0x0, 0x0, 0x0, + + /* U+038E "Ύ" */ + 0x0, 0x8f, 0xfe, 0x10, 0xbf, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0x90, 0x1f, + 0xff, 0x30, 0x1, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xd0, 0x7, 0xff, 0x60, + 0x0, 0x6, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf3, 0x0, 0xef, 0xa0, 0x0, 0x0, + 0xb, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xf8, 0x0, 0x16, 0x60, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x8f, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x30, 0x0, 0x0, 0x3f, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfd, 0x0, + 0x0, 0xd, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xf7, 0x0, 0x8, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xf2, 0x2, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xb0, 0xbf, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x9f, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+038F "Ώ" */ + 0x0, 0x8f, 0xfe, 0x10, 0x0, 0x6b, 0xdf, 0xfe, + 0xc8, 0x20, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x30, + 0x6, 0xef, 0xff, 0xff, 0xff, 0xff, 0xa1, 0x0, + 0x0, 0x7, 0xff, 0x60, 0xa, 0xff, 0xff, 0xda, + 0xac, 0xff, 0xff, 0xd2, 0x0, 0x0, 0xef, 0xa0, + 0xa, 0xff, 0xfb, 0x20, 0x0, 0x1, 0x8f, 0xff, + 0xd1, 0x0, 0x16, 0x60, 0x5, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x90, 0x0, 0x0, + 0x0, 0xef, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x20, 0x0, 0x0, 0x5f, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf9, 0x0, + 0x0, 0xa, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xe0, 0x0, 0x0, 0xef, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0x20, 0x0, 0xf, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xf4, 0x0, 0x0, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0x40, 0x0, 0xf, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf4, 0x0, 0x0, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x30, 0x0, 0xc, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf0, 0x0, + 0x0, 0x7f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xfb, 0x0, 0x0, 0x1, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x50, + 0x0, 0x0, 0x9, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xd0, 0x0, 0x0, 0x0, 0x1e, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xfd, 0x20, 0x0, 0x0, 0x9f, 0xf7, + 0x0, 0x0, 0x0, 0x3, 0xbb, 0xbb, 0xdf, 0xff, + 0x60, 0x3, 0xef, 0xfe, 0xbb, 0xbb, 0x60, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xf9, 0x0, 0x5, 0xff, 0xff, 0xff, + 0xff, 0x90, 0x5, 0xff, 0xff, 0xff, 0xff, 0x90, + + /* U+0390 "ΐ" */ + 0x0, 0x0, 0x0, 0x38, 0x82, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xfd, 0x0, 0x0, 0x2f, 0xf9, 0x4, + 0xff, 0x27, 0xff, 0x32, 0xff, 0x90, 0xbf, 0x70, + 0x7f, 0xf3, 0x2f, 0xf9, 0x2f, 0xc0, 0x7, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xf0, 0x0, 0x0, + + /* U+0391 "Α" */ + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xfe, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0x6f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xd0, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf8, 0xa, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0x30, 0x4f, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xd0, 0x0, 0xef, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xf7, 0x0, 0x8, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0x10, 0x0, 0x2f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xb0, + 0x0, 0x0, 0xcf, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xf5, 0x0, 0x0, 0x6, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xd7, 0x77, 0x77, 0x77, 0xdf, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x8, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xfc, 0x0, 0x0, 0x0, 0xef, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf2, 0x0, 0x0, + 0x4f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0x90, 0x0, 0xa, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x0, 0x1, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf6, 0x0, 0x7f, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xc0, 0xd, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0x30, + + /* U+0392 "Β" */ + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xeb, 0x71, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x50, 0x0, 0xaf, 0xfd, 0xbb, 0xbb, 0xbc, 0xef, + 0xff, 0xf5, 0x0, 0xaf, 0xf6, 0x0, 0x0, 0x0, + 0x2, 0xbf, 0xfe, 0x0, 0xaf, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0x50, 0xaf, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0x70, 0xaf, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x70, 0xaf, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0x50, + 0xaf, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xfe, + 0x0, 0xaf, 0xf6, 0x0, 0x0, 0x0, 0x26, 0xdf, + 0xf5, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x40, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x60, 0x0, 0xaf, 0xfd, 0xbb, 0xbb, + 0xbc, 0xdf, 0xff, 0xfc, 0x10, 0xaf, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x5d, 0xff, 0xc0, 0xaf, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf4, 0xaf, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf8, + 0xaf, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xfa, 0xaf, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf8, 0xaf, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xf5, 0xaf, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x4d, 0xff, 0xe0, 0xaf, 0xfd, 0xbb, 0xbb, + 0xbb, 0xce, 0xff, 0xff, 0x40, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe5, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xed, 0xa6, 0x0, 0x0, + + /* U+0393 "Γ" */ + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x7f, + 0xfe, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xa7, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0394 "Δ" */ + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xfe, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0x6f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xd0, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf8, 0xa, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0x30, 0x4f, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xd0, 0x0, 0xef, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xf7, 0x0, 0x8, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0x10, 0x0, 0x2f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xb0, + 0x0, 0x0, 0xcf, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xf6, 0x0, 0x0, 0x6, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0xaf, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xf4, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x2f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0x50, 0x0, + 0x0, 0x8, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xfc, 0x0, 0x0, 0x0, 0xef, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf2, 0x0, 0x0, + 0x5f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0x90, 0x0, 0xb, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x0, 0x1, 0xff, + 0xfc, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xff, + 0xf6, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc0, 0xd, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x30, + + /* U+0395 "Ε" */ + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf1, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf1, 0x7f, 0xfe, 0xbb, 0xbb, 0xbb, 0xbb, + 0xbb, 0xbb, 0xb1, 0x7f, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x30, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x30, 0x7f, 0xfd, 0xbb, 0xbb, + 0xbb, 0xbb, 0xbb, 0xbb, 0x20, 0x7f, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfd, 0xbb, 0xbb, + 0xbb, 0xbb, 0xbb, 0xbb, 0xb7, 0x7f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + + /* U+0396 "Ζ" */ + 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x50, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf5, 0x1, 0xbb, 0xbb, 0xbb, 0xbb, + 0xbb, 0xbb, 0xdf, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2e, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xdf, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xef, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xcb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0x76, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfb, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb0, + + /* U+0397 "Η" */ + 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0x87, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xf8, 0x7f, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0x87, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf8, 0x7f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x87, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xf8, 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0x87, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xf8, 0x7f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0x87, 0xff, 0xeb, + 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xdf, 0xf8, 0x7f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x87, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0x87, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xf8, 0x7f, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x87, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf8, + 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0x87, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xf8, 0x7f, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0x87, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf8, 0x7f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x87, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xf8, 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0x80, + + /* U+0398 "Θ" */ + 0x0, 0x0, 0x0, 0x5, 0x9d, 0xef, 0xed, 0x94, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6e, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x40, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xfd, 0xba, 0xbe, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xa2, 0x0, + 0x0, 0x3, 0xbf, 0xff, 0x90, 0x0, 0x0, 0x8f, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0x50, 0x0, 0x1f, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xfe, 0x0, 0x8, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf7, + 0x0, 0xef, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xc0, 0x2f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x15, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xf3, 0x6f, 0xfb, 0x0, 0x1f, 0xff, + 0xff, 0xff, 0xff, 0x0, 0xc, 0xff, 0x57, 0xff, + 0xa0, 0x1, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0xbf, 0xf6, 0x7f, 0xfa, 0x0, 0xb, 0xbb, 0xbb, + 0xbb, 0xbb, 0x0, 0xc, 0xff, 0x55, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xf3, 0x2f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x10, 0xef, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xd0, + 0x9, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xf7, 0x0, 0x2f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, + 0x8f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x60, 0x0, 0x0, 0xbf, 0xff, 0x91, 0x0, + 0x0, 0x2, 0xaf, 0xff, 0x90, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xfd, 0xa9, 0xad, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x5e, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xad, 0xff, 0xed, 0x94, 0x0, 0x0, 0x0, + 0x0, + + /* U+0399 "Ι" */ + 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, + 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, + 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, + 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, + 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, + 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, + + /* U+039A "Κ" */ + 0xaf, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x50, 0xaf, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf5, 0x0, 0xaf, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x50, 0x0, 0xaf, 0xf6, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xf4, 0x0, 0x0, + 0xaf, 0xf6, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x40, + 0x0, 0x0, 0xaf, 0xf6, 0x0, 0x0, 0xb, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0xaf, 0xf6, 0x0, 0x0, + 0xbf, 0xff, 0x30, 0x0, 0x0, 0x0, 0xaf, 0xf6, + 0x0, 0xb, 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xf6, 0x0, 0xbf, 0xfe, 0x20, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xf6, 0xa, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf6, 0xaf, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfe, + 0xff, 0xdc, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xfd, 0x11, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xd1, 0x0, 0x5f, 0xff, + 0x50, 0x0, 0x0, 0x0, 0xaf, 0xfd, 0x10, 0x0, + 0xa, 0xff, 0xf2, 0x0, 0x0, 0x0, 0xaf, 0xf6, + 0x0, 0x0, 0x1, 0xef, 0xfc, 0x0, 0x0, 0x0, + 0xaf, 0xf6, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x80, + 0x0, 0x0, 0xaf, 0xf6, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xf4, 0x0, 0x0, 0xaf, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xfe, 0x10, 0x0, 0xaf, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xb0, 0x0, + 0xaf, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf7, 0x0, 0xaf, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x30, 0xaf, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xd0, + + /* U+039B "Λ" */ + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xef, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0x6f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xb, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xfb, 0x6, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf6, 0x1, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xf0, 0x0, 0xbf, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xa0, 0x0, 0x5f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0x40, + 0x0, 0xf, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xfe, 0x0, 0x0, 0xa, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf8, 0x0, 0x0, 0x4, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf2, + 0x0, 0x0, 0x0, 0xef, 0xf1, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x9f, 0xf7, + 0x0, 0x0, 0x0, 0x8, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x3f, 0xfd, 0x0, 0x0, 0x0, 0xe, 0xff, + 0x10, 0x0, 0x0, 0x0, 0xd, 0xff, 0x30, 0x0, + 0x0, 0x4f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0x90, 0x0, 0x0, 0xbf, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xf0, 0x0, 0x1, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf6, + 0x0, 0x7, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xfc, 0x0, 0xd, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x20, 0x3f, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0x80, 0xaf, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xe0, + + /* U+039C "Μ" */ + 0x9f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x49, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf4, 0x9f, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0x49, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xf4, 0x9f, 0xfa, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfc, + 0xff, 0x49, 0xff, 0x5f, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xfb, 0xaf, 0xf4, 0x9f, 0xf5, 0xaf, + 0xf2, 0x0, 0x0, 0x0, 0x1, 0xff, 0x6a, 0xff, + 0x49, 0xff, 0x54, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x6f, 0xf1, 0xaf, 0xf4, 0x9f, 0xf5, 0xe, 0xfc, + 0x0, 0x0, 0x0, 0xb, 0xfb, 0xa, 0xff, 0x49, + 0xff, 0x50, 0x9f, 0xf2, 0x0, 0x0, 0x1, 0xff, + 0x50, 0xaf, 0xf4, 0x9f, 0xf5, 0x4, 0xff, 0x70, + 0x0, 0x0, 0x6f, 0xf0, 0xa, 0xff, 0x49, 0xff, + 0x50, 0xe, 0xfc, 0x0, 0x0, 0xc, 0xfa, 0x0, + 0xaf, 0xf4, 0x9f, 0xf5, 0x0, 0x9f, 0xf2, 0x0, + 0x1, 0xff, 0x50, 0xa, 0xff, 0x49, 0xff, 0x50, + 0x4, 0xff, 0x70, 0x0, 0x7f, 0xf0, 0x0, 0xaf, + 0xf4, 0x9f, 0xf5, 0x0, 0xe, 0xfc, 0x0, 0xc, + 0xfa, 0x0, 0xa, 0xff, 0x49, 0xff, 0x50, 0x0, + 0x9f, 0xf2, 0x2, 0xff, 0x40, 0x0, 0xaf, 0xf4, + 0x9f, 0xf5, 0x0, 0x3, 0xff, 0x70, 0x7f, 0xe0, + 0x0, 0xa, 0xff, 0x49, 0xff, 0x50, 0x0, 0xe, + 0xfc, 0xc, 0xf9, 0x0, 0x0, 0xaf, 0xf4, 0x9f, + 0xf5, 0x0, 0x0, 0x9f, 0xf3, 0xff, 0x30, 0x0, + 0xa, 0xff, 0x49, 0xff, 0x50, 0x0, 0x3, 0xff, + 0xdf, 0xe0, 0x0, 0x0, 0xaf, 0xf4, 0x9f, 0xf5, + 0x0, 0x0, 0xe, 0xff, 0xf8, 0x0, 0x0, 0xa, + 0xff, 0x49, 0xff, 0x50, 0x0, 0x0, 0x8f, 0xff, + 0x30, 0x0, 0x0, 0xaf, 0xf4, 0x9f, 0xf5, 0x0, + 0x0, 0x3, 0xff, 0xd0, 0x0, 0x0, 0xa, 0xff, + 0x40, + + /* U+039D "Ν" */ + 0x7f, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0x97, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xf9, 0x7f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0x97, 0xff, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf9, 0x7f, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x5, 0xff, 0x97, + 0xff, 0xaf, 0xff, 0x40, 0x0, 0x0, 0x0, 0x5f, + 0xf9, 0x7f, 0xf7, 0x8f, 0xfe, 0x10, 0x0, 0x0, + 0x5, 0xff, 0x97, 0xff, 0x70, 0xdf, 0xfa, 0x0, + 0x0, 0x0, 0x5f, 0xf9, 0x7f, 0xf7, 0x3, 0xff, + 0xf4, 0x0, 0x0, 0x5, 0xff, 0x97, 0xff, 0x70, + 0x8, 0xff, 0xe1, 0x0, 0x0, 0x5f, 0xf9, 0x7f, + 0xf7, 0x0, 0xd, 0xff, 0xa0, 0x0, 0x5, 0xff, + 0x97, 0xff, 0x70, 0x0, 0x3f, 0xff, 0x40, 0x0, + 0x5f, 0xf9, 0x7f, 0xf7, 0x0, 0x0, 0x8f, 0xfe, + 0x10, 0x5, 0xff, 0x97, 0xff, 0x70, 0x0, 0x0, + 0xdf, 0xfa, 0x0, 0x5f, 0xf9, 0x7f, 0xf7, 0x0, + 0x0, 0x3, 0xff, 0xf4, 0x5, 0xff, 0x97, 0xff, + 0x70, 0x0, 0x0, 0x8, 0xff, 0xe1, 0x5f, 0xf9, + 0x7f, 0xf7, 0x0, 0x0, 0x0, 0xd, 0xff, 0xa5, + 0xff, 0x97, 0xff, 0x70, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xaf, 0xf9, 0x7f, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x97, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf9, 0x7f, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x97, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xf9, 0x7f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x90, + + /* U+039E "Ξ" */ + 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0x0, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xa0, 0xa, 0xbb, 0xbb, 0xbb, 0xbb, + 0xbb, 0xbb, 0xbb, 0xb7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4b, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0x20, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3b, 0xbb, + 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0x14, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf1, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x10, + + /* U+039F "Ο" */ + 0x0, 0x0, 0x0, 0x5, 0x9d, 0xef, 0xed, 0x94, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6e, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x40, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xfd, 0xba, 0xbe, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xa2, 0x0, + 0x0, 0x3, 0xbf, 0xff, 0x90, 0x0, 0x0, 0x8f, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0x50, 0x0, 0x1f, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xfe, 0x0, 0x8, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf7, + 0x0, 0xef, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xc0, 0x2f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x15, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xf3, 0x6f, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x57, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf6, 0x7f, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0x55, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xf3, 0x2f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x10, 0xef, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xd0, + 0x9, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xf7, 0x0, 0x2f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, + 0x8f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x60, 0x0, 0x0, 0xbf, 0xff, 0x91, 0x0, + 0x0, 0x2, 0xaf, 0xff, 0x90, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xfd, 0xa9, 0xad, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x5e, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xad, 0xff, 0xed, 0x94, 0x0, 0x0, 0x0, + 0x0, + + /* U+03A0 "Π" */ + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x87, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf8, 0x7f, 0xfe, 0xbb, 0xbb, 0xbb, + 0xbb, 0xbb, 0xbd, 0xff, 0x87, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf8, 0x7f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x87, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xf8, 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0x87, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xf8, 0x7f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0x87, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf8, 0x7f, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0x87, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf8, 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0x87, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xf8, 0x7f, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x87, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf8, + 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0x87, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xf8, 0x7f, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0x87, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf8, 0x7f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x87, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xf8, 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0x80, + + /* U+03A1 "Ρ" */ + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xc8, 0x30, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x8f, 0xfd, 0xbb, 0xbb, 0xbb, 0xcd, + 0xff, 0xff, 0x90, 0x8f, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x1a, 0xff, 0xf3, 0x8f, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xfa, 0x8f, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, 0x8f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfe, 0x8f, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfe, + 0x8f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xfb, 0x8f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf6, 0x8f, 0xf8, 0x0, 0x0, 0x0, 0x3, + 0x8f, 0xff, 0xe0, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x30, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc2, 0x0, 0x8f, 0xfd, 0xbb, + 0xbb, 0xbb, 0xa9, 0x62, 0x0, 0x0, 0x8f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A3 "Σ" */ + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe0, 0xbf, 0xfe, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, + 0xba, 0x4, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xfe, 0xbb, 0xbb, 0xbb, 0xbb, + 0xbb, 0xbb, 0x5b, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf8, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x80, + + /* U+03A4 "Τ" */ + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x3b, 0xbb, 0xbb, 0xbb, 0xef, + 0xfc, 0xbb, 0xbb, 0xbb, 0x90, 0x0, 0x0, 0x0, + 0xc, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf4, 0x0, + 0x0, 0x0, 0x0, + + /* U+03A5 "Υ" */ + 0x9f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xb0, 0xd, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x10, 0x3, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf5, + 0x0, 0x0, 0x9f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xa0, 0x0, 0x0, 0xd, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x6f, 0xfe, 0x10, 0x0, 0x0, + 0x3, 0xff, 0xf5, 0x0, 0x0, 0x1, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfe, 0x10, 0x0, + 0xb, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xa0, 0x0, 0x5f, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xf4, 0x1, 0xef, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfd, + 0x9, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0x9f, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A6 "Φ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x57, 0x72, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0x67, 0xef, 0xfa, 0x65, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2a, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x60, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x20, 0x0, + 0x0, 0x6f, 0xff, 0xd6, 0x20, 0xcf, 0xf4, 0x14, + 0x9f, 0xff, 0xe1, 0x0, 0x2, 0xff, 0xf8, 0x0, + 0x0, 0xcf, 0xf4, 0x0, 0x2, 0xdf, 0xfc, 0x0, + 0xc, 0xff, 0x90, 0x0, 0x0, 0xcf, 0xf4, 0x0, + 0x0, 0x2f, 0xff, 0x50, 0x2f, 0xff, 0x10, 0x0, + 0x0, 0xcf, 0xf4, 0x0, 0x0, 0x8, 0xff, 0xb0, + 0x7f, 0xfb, 0x0, 0x0, 0x0, 0xcf, 0xf4, 0x0, + 0x0, 0x2, 0xff, 0xf0, 0x9f, 0xf8, 0x0, 0x0, + 0x0, 0xcf, 0xf4, 0x0, 0x0, 0x0, 0xff, 0xf2, + 0xaf, 0xf8, 0x0, 0x0, 0x0, 0xcf, 0xf4, 0x0, + 0x0, 0x0, 0xef, 0xf2, 0x9f, 0xf8, 0x0, 0x0, + 0x0, 0xcf, 0xf4, 0x0, 0x0, 0x0, 0xff, 0xf1, + 0x7f, 0xfb, 0x0, 0x0, 0x0, 0xcf, 0xf4, 0x0, + 0x0, 0x2, 0xff, 0xf0, 0x3f, 0xff, 0x10, 0x0, + 0x0, 0xcf, 0xf4, 0x0, 0x0, 0x7, 0xff, 0xb0, + 0xc, 0xff, 0xa0, 0x0, 0x0, 0xcf, 0xf4, 0x0, + 0x0, 0x1e, 0xff, 0x50, 0x3, 0xff, 0xf9, 0x0, + 0x0, 0xcf, 0xf4, 0x0, 0x2, 0xdf, 0xfc, 0x0, + 0x0, 0x6f, 0xff, 0xe7, 0x30, 0xcf, 0xf4, 0x14, + 0x9f, 0xff, 0xd1, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x10, 0x0, + 0x0, 0x0, 0x29, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0x67, 0xef, 0xfa, 0x75, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+03A7 "Χ" */ + 0x7, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x20, 0x0, 0xbf, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf6, 0x0, 0x0, 0x1e, + 0xff, 0x80, 0x0, 0x0, 0x0, 0xa, 0xff, 0xa0, + 0x0, 0x0, 0x5, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x6f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfe, + 0x10, 0x0, 0x3, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xa0, 0x0, 0x1d, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf5, 0x0, + 0xaf, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x16, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xbf, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfd, 0x8, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf2, 0x0, 0xdf, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0x60, 0x0, 0x3f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfb, 0x0, + 0x0, 0x7, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0xcf, 0xfd, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xa0, 0x0, 0x1, 0xef, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf5, 0x0, 0xb, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0x20, 0x7f, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xc0, + + /* U+03A8 "Ψ" */ + 0xf, 0xff, 0x0, 0x0, 0x0, 0x2f, 0xfe, 0x0, + 0x0, 0x0, 0x4f, 0xfc, 0xf, 0xff, 0x0, 0x0, + 0x0, 0x2f, 0xfe, 0x0, 0x0, 0x0, 0x4f, 0xfc, + 0xf, 0xff, 0x0, 0x0, 0x0, 0x2f, 0xfe, 0x0, + 0x0, 0x0, 0x4f, 0xfc, 0xf, 0xff, 0x0, 0x0, + 0x0, 0x2f, 0xfe, 0x0, 0x0, 0x0, 0x4f, 0xfc, + 0xf, 0xff, 0x0, 0x0, 0x0, 0x2f, 0xfe, 0x0, + 0x0, 0x0, 0x4f, 0xfc, 0xf, 0xff, 0x0, 0x0, + 0x0, 0x2f, 0xfe, 0x0, 0x0, 0x0, 0x4f, 0xfc, + 0xf, 0xff, 0x0, 0x0, 0x0, 0x2f, 0xfe, 0x0, + 0x0, 0x0, 0x5f, 0xfb, 0xf, 0xff, 0x10, 0x0, + 0x0, 0x2f, 0xfe, 0x0, 0x0, 0x0, 0x6f, 0xfa, + 0xe, 0xff, 0x30, 0x0, 0x0, 0x2f, 0xfe, 0x0, + 0x0, 0x0, 0x8f, 0xf9, 0xb, 0xff, 0x70, 0x0, + 0x0, 0x2f, 0xfe, 0x0, 0x0, 0x0, 0xcf, 0xf6, + 0x7, 0xff, 0xd0, 0x0, 0x0, 0x2f, 0xfe, 0x0, + 0x0, 0x3, 0xff, 0xf2, 0x1, 0xff, 0xf9, 0x0, + 0x0, 0x2f, 0xfe, 0x0, 0x0, 0x1d, 0xff, 0xc0, + 0x0, 0x7f, 0xff, 0xb4, 0x0, 0x2f, 0xfe, 0x0, + 0x5, 0xef, 0xff, 0x30, 0x0, 0xa, 0xff, 0xff, + 0xeb, 0xaf, 0xff, 0xab, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, 0x0, 0x6a, + 0xde, 0xff, 0xff, 0xfe, 0xc9, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+03A9 "Ω" */ + 0x0, 0x0, 0x0, 0x17, 0xbe, 0xff, 0xec, 0x72, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x1, + 0xcf, 0xff, 0xfc, 0xaa, 0xcf, 0xff, 0xfc, 0x10, + 0x0, 0x0, 0xc, 0xff, 0xf9, 0x10, 0x0, 0x1, + 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x8f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf7, 0x0, 0x1, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x10, 0x8, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0x70, 0xd, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xc0, + 0xf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xf0, 0x2f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf1, 0x3f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf2, 0x3f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf2, 0x1f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf0, 0xe, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xd0, 0xa, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0x90, 0x3, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0x20, + 0x0, 0xbf, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xfa, 0x0, 0x0, 0x2f, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xe1, 0x0, 0x0, 0x5, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x9, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x6f, 0xfb, 0x10, 0x0, 0x1, + 0xbf, 0xf5, 0x0, 0x0, 0x5b, 0xbb, 0xbe, 0xff, + 0xf4, 0x0, 0x5f, 0xff, 0xeb, 0xbb, 0xb4, 0x7f, + 0xff, 0xff, 0xff, 0xf7, 0x0, 0x7f, 0xff, 0xff, + 0xff, 0xf6, 0x7f, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0xf6, + + /* U+03AA "Ϊ" */ + 0x3, 0x32, 0x0, 0x3, 0x32, 0xf, 0xfe, 0x0, + 0x3f, 0xfc, 0xf, 0xfe, 0x0, 0x3f, 0xfc, 0xf, + 0xfe, 0x0, 0x3f, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xf0, 0x0, 0x0, 0x1, + 0xff, 0xf0, 0x0, 0x0, 0x1, 0xff, 0xf0, 0x0, + 0x0, 0x1, 0xff, 0xf0, 0x0, 0x0, 0x1, 0xff, + 0xf0, 0x0, 0x0, 0x1, 0xff, 0xf0, 0x0, 0x0, + 0x1, 0xff, 0xf0, 0x0, 0x0, 0x1, 0xff, 0xf0, + 0x0, 0x0, 0x1, 0xff, 0xf0, 0x0, 0x0, 0x1, + 0xff, 0xf0, 0x0, 0x0, 0x1, 0xff, 0xf0, 0x0, + 0x0, 0x1, 0xff, 0xf0, 0x0, 0x0, 0x1, 0xff, + 0xf0, 0x0, 0x0, 0x1, 0xff, 0xf0, 0x0, 0x0, + 0x1, 0xff, 0xf0, 0x0, 0x0, 0x1, 0xff, 0xf0, + 0x0, 0x0, 0x1, 0xff, 0xf0, 0x0, 0x0, 0x1, + 0xff, 0xf0, 0x0, 0x0, 0x1, 0xff, 0xf0, 0x0, + 0x0, 0x1, 0xff, 0xf0, 0x0, 0x0, 0x1, 0xff, + 0xf0, 0x0, 0x0, 0x1, 0xff, 0xf0, 0x0, 0x0, + 0x1, 0xff, 0xf0, 0x0, + + /* U+03AB "Ϋ" */ + 0x0, 0x0, 0x0, 0x23, 0x30, 0x0, 0x33, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf2, + 0x0, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xf2, 0x0, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf2, 0x0, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xb0, 0xd, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x10, 0x3, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf5, 0x0, + 0x0, 0x9f, 0xff, 0x10, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xa0, 0x0, 0x0, 0xd, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x6f, 0xfe, 0x10, 0x0, 0x0, 0x3, + 0xff, 0xf5, 0x0, 0x0, 0x1, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xfe, 0x10, 0x0, 0xb, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xa0, 0x0, 0x5f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf4, 0x1, 0xef, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfd, 0x9, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x9f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+03AC "ά" */ + 0x0, 0x0, 0x0, 0x0, 0xef, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xfe, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x46, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x18, 0xcf, 0xfd, + 0x81, 0x0, 0xbf, 0xf2, 0x0, 0x4e, 0xff, 0xff, + 0xff, 0xe3, 0xf, 0xfd, 0x0, 0x2f, 0xff, 0xd7, + 0x57, 0xdf, 0xe6, 0xff, 0x90, 0xc, 0xff, 0xb0, + 0x0, 0x0, 0x9f, 0xff, 0xf5, 0x3, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x10, 0x8f, 0xfa, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xe0, 0xb, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x3f, 0xfa, 0x0, 0xdf, + 0xf4, 0x0, 0x0, 0x0, 0x1, 0xff, 0x70, 0xd, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x1f, 0xf5, 0x0, + 0xdf, 0xf4, 0x0, 0x0, 0x0, 0x1, 0xff, 0x70, + 0xb, 0xff, 0x60, 0x0, 0x0, 0x0, 0x4f, 0xfa, + 0x0, 0x8f, 0xfa, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xd0, 0x3, 0xff, 0xf1, 0x0, 0x0, 0x1, 0xef, + 0xff, 0x10, 0xb, 0xff, 0xb0, 0x0, 0x0, 0xbf, + 0xff, 0xf4, 0x0, 0x2f, 0xff, 0xd7, 0x57, 0xef, + 0xe5, 0xff, 0x80, 0x0, 0x3e, 0xff, 0xff, 0xff, + 0xf4, 0xf, 0xfc, 0x0, 0x0, 0x18, 0xdf, 0xfd, + 0x92, 0x0, 0xaf, 0xf2, + + /* U+03AD "έ" */ + 0x0, 0x0, 0x0, 0xaf, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x9, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x1, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x26, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6b, + 0xef, 0xeb, 0x60, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xff, 0xd3, 0x0, 0x6f, 0xfe, 0x87, 0x9e, 0xff, + 0x80, 0xd, 0xff, 0x20, 0x0, 0x8, 0x50, 0x0, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfc, 0x41, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x9, 0xff, 0xf9, 0x65, 0x0, 0x0, 0x2, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0x80, 0x0, 0x0, + 0x1, 0x0, 0x3f, 0xfe, 0x10, 0x0, 0x7, 0xf8, + 0x0, 0xcf, 0xfe, 0x75, 0x7d, 0xff, 0xf3, 0x2, + 0xef, 0xff, 0xff, 0xff, 0xe4, 0x0, 0x1, 0x8c, + 0xff, 0xeb, 0x60, 0x0, + + /* U+03AE "ή" */ + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, 0x5, 0x63, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xb0, 0x18, 0xdf, 0xfd, 0x81, 0x0, + 0xdf, 0xb3, 0xef, 0xff, 0xff, 0xfe, 0x30, 0xdf, + 0xde, 0xfd, 0x87, 0x9e, 0xff, 0xe0, 0xdf, 0xff, + 0x70, 0x0, 0x1, 0xef, 0xf5, 0xdf, 0xfa, 0x0, + 0x0, 0x0, 0x7f, 0xf8, 0xdf, 0xf4, 0x0, 0x0, + 0x0, 0x4f, 0xf9, 0xdf, 0xf1, 0x0, 0x0, 0x0, + 0x2f, 0xfa, 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x2f, + 0xfa, 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xfa, + 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xfa, 0xdf, + 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xfa, 0xdf, 0xf0, + 0x0, 0x0, 0x0, 0x2f, 0xfa, 0xdf, 0xf0, 0x0, + 0x0, 0x0, 0x2f, 0xfa, 0xdf, 0xf0, 0x0, 0x0, + 0x0, 0x2f, 0xfa, 0xdf, 0xf0, 0x0, 0x0, 0x0, + 0x2f, 0xfa, 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x2f, + 0xfa, 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xfa, + + /* U+03AF "ί" */ + 0x0, 0x26, 0x66, 0x10, 0xa, 0xff, 0xb0, 0x2, + 0xff, 0xe1, 0x0, 0x9f, 0xf3, 0x0, 0x1f, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xf0, 0x0, 0xd, 0xff, 0x0, 0x0, + 0xdf, 0xf0, 0x0, 0xd, 0xff, 0x0, 0x0, 0xdf, + 0xf0, 0x0, 0xd, 0xff, 0x0, 0x0, 0xdf, 0xf0, + 0x0, 0xd, 0xff, 0x0, 0x0, 0xdf, 0xf0, 0x0, + 0xd, 0xff, 0x0, 0x0, 0xdf, 0xf0, 0x0, 0xd, + 0xff, 0x0, 0x0, 0xdf, 0xf0, 0x0, 0xd, 0xff, + 0x0, 0x0, 0xdf, 0xf0, 0x0, 0xd, 0xff, 0x0, + 0x0, 0xdf, 0xf0, 0x0, + + /* U+03B0 "ΰ" */ + 0x0, 0x0, 0x0, 0x6f, 0xf5, 0x0, 0x0, 0xe, + 0xfc, 0x0, 0xef, 0x94, 0xff, 0x70, 0xe, 0xfc, + 0x6, 0xfc, 0x4, 0xff, 0x70, 0xe, 0xfc, 0xe, + 0xe1, 0x4, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xf0, 0x0, 0x0, 0x0, 0x6f, 0xf6, + 0xef, 0xf0, 0x0, 0x0, 0x0, 0x6f, 0xf6, 0xef, + 0xf0, 0x0, 0x0, 0x0, 0x6f, 0xf6, 0xef, 0xf0, + 0x0, 0x0, 0x0, 0x6f, 0xf6, 0xef, 0xf0, 0x0, + 0x0, 0x0, 0x6f, 0xf6, 0xef, 0xf0, 0x0, 0x0, + 0x0, 0x6f, 0xf6, 0xef, 0xf0, 0x0, 0x0, 0x0, + 0x6f, 0xf6, 0xef, 0xf0, 0x0, 0x0, 0x0, 0x6f, + 0xf6, 0xef, 0xf0, 0x0, 0x0, 0x0, 0x6f, 0xf6, + 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x6f, 0xf6, 0xdf, + 0xf0, 0x0, 0x0, 0x0, 0x7f, 0xf5, 0xcf, 0xf1, + 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x9f, 0xf6, 0x0, + 0x0, 0x0, 0xdf, 0xf0, 0x4f, 0xfe, 0x20, 0x0, + 0x9, 0xff, 0xb0, 0xa, 0xff, 0xf8, 0x56, 0xcf, + 0xff, 0x20, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xe4, + 0x0, 0x0, 0x5, 0xbe, 0xff, 0xc8, 0x10, 0x0, + + /* U+03B1 "α" */ + 0x0, 0x1, 0x8c, 0xff, 0xd8, 0x10, 0xb, 0xff, + 0x20, 0x4, 0xef, 0xff, 0xff, 0xfe, 0x30, 0xff, + 0xd0, 0x2, 0xff, 0xfd, 0x75, 0x7d, 0xfe, 0x6f, + 0xf9, 0x0, 0xcf, 0xfb, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x50, 0x3f, 0xff, 0x10, 0x0, 0x0, 0xd, + 0xff, 0xf1, 0x8, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x7f, 0xfe, 0x0, 0xbf, 0xf6, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xa0, 0xd, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x1f, 0xf7, 0x0, 0xdf, 0xf3, 0x0, 0x0, + 0x0, 0x1, 0xff, 0x50, 0xd, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x1f, 0xf7, 0x0, 0xbf, 0xf6, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xa0, 0x8, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x8f, 0xfd, 0x0, 0x3f, 0xff, + 0x10, 0x0, 0x0, 0x1e, 0xff, 0xf1, 0x0, 0xbf, + 0xfb, 0x0, 0x0, 0xb, 0xff, 0xff, 0x40, 0x2, + 0xff, 0xfd, 0x75, 0x7e, 0xfe, 0x5f, 0xf8, 0x0, + 0x3, 0xef, 0xff, 0xff, 0xff, 0x40, 0xff, 0xc0, + 0x0, 0x1, 0x8d, 0xff, 0xd9, 0x20, 0xa, 0xff, + 0x20, + + /* U+03B2 "β" */ + 0x0, 0x1, 0x7c, 0xef, 0xeb, 0x50, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x8, + 0xff, 0xf9, 0x66, 0x9f, 0xff, 0x90, 0x2, 0xff, + 0xe2, 0x0, 0x0, 0x1d, 0xff, 0x20, 0x7f, 0xf5, + 0x0, 0x0, 0x0, 0x3f, 0xf7, 0xa, 0xff, 0x10, + 0x0, 0x0, 0x0, 0xff, 0x80, 0xcf, 0xf0, 0x0, + 0x0, 0x0, 0x3f, 0xf6, 0xc, 0xff, 0x0, 0x0, + 0x0, 0xb, 0xfe, 0x10, 0xdf, 0xf0, 0x0, 0x2, + 0x6c, 0xfe, 0x30, 0xd, 0xff, 0x0, 0x8f, 0xff, + 0xe8, 0x10, 0x0, 0xdf, 0xf0, 0x8, 0xff, 0xff, + 0xd8, 0x10, 0xd, 0xff, 0x0, 0x1, 0x26, 0xcf, + 0xfe, 0x20, 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x8f, + 0xfd, 0xd, 0xff, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xf7, 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xcd, 0xff, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xfe, + 0xdf, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xff, 0xed, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x1f, 0xfc, 0xdf, + 0xfb, 0x0, 0x0, 0x0, 0x7, 0xff, 0x8d, 0xff, + 0xf8, 0x0, 0x0, 0x2, 0xff, 0xf1, 0xdf, 0xfe, + 0xfb, 0x41, 0x26, 0xef, 0xf7, 0xd, 0xff, 0x2e, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0xdf, 0xf0, 0x7, + 0xcf, 0xfe, 0xa3, 0x0, 0xd, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+03B3 "γ" */ + 0x6f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf6, + 0x1f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf1, + 0xa, 0xff, 0x30, 0x0, 0x0, 0x2, 0xff, 0xa0, + 0x5, 0xff, 0x90, 0x0, 0x0, 0x8, 0xff, 0x40, + 0x0, 0xef, 0xe0, 0x0, 0x0, 0xe, 0xfe, 0x0, + 0x0, 0x9f, 0xf4, 0x0, 0x0, 0x4f, 0xf8, 0x0, + 0x0, 0x3f, 0xfa, 0x0, 0x0, 0x9f, 0xf2, 0x0, + 0x0, 0xd, 0xff, 0x0, 0x0, 0xff, 0xc0, 0x0, + 0x0, 0x7, 0xff, 0x50, 0x5, 0xff, 0x60, 0x0, + 0x0, 0x1, 0xff, 0xb0, 0xb, 0xff, 0x10, 0x0, + 0x0, 0x0, 0xbf, 0xf1, 0x1f, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xf6, 0x6f, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xfc, 0xcf, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xf6, 0x0, 0x0, 0x0, + + /* U+03B4 "δ" */ + 0x4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, + 0x4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, + 0x0, 0xaf, 0xfe, 0x54, 0x44, 0x44, 0x44, 0x10, + 0x0, 0x6, 0xff, 0xc1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3d, 0xfe, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7c, 0xff, 0xff, 0xc1, 0x0, 0x0, + 0x0, 0x2e, 0xff, 0xff, 0xff, 0xfe, 0x40, 0x0, + 0x2, 0xff, 0xfc, 0x52, 0x26, 0xef, 0xf5, 0x0, + 0xc, 0xff, 0xa0, 0x0, 0x0, 0x1c, 0xff, 0x30, + 0x3f, 0xfe, 0x0, 0x0, 0x0, 0x2, 0xff, 0xd0, + 0x8f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf3, + 0xbf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf7, + 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf9, + 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfa, + 0xcf, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf9, + 0xaf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf8, + 0x6f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf4, + 0x1f, 0xff, 0x20, 0x0, 0x0, 0x3, 0xff, 0xe0, + 0x8, 0xff, 0xd1, 0x0, 0x0, 0x2e, 0xff, 0x70, + 0x0, 0xdf, 0xff, 0x95, 0x59, 0xff, 0xfb, 0x0, + 0x0, 0x1c, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x5a, 0xef, 0xfd, 0x93, 0x0, 0x0, + + /* U+03B5 "ε" */ + 0x0, 0x6, 0xbe, 0xfe, 0xb6, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0xfd, 0x30, 0x6, 0xff, 0xe8, + 0x79, 0xef, 0xf8, 0x0, 0xdf, 0xf2, 0x0, 0x0, + 0x85, 0x0, 0xf, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xc4, 0x10, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x9f, 0xff, 0x96, 0x50, 0x0, + 0x0, 0x2f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x6, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf8, + 0x0, 0x0, 0x0, 0x10, 0x3, 0xff, 0xe1, 0x0, + 0x0, 0x7f, 0x80, 0xc, 0xff, 0xe7, 0x57, 0xdf, + 0xff, 0x30, 0x2e, 0xff, 0xff, 0xff, 0xfe, 0x40, + 0x0, 0x18, 0xcf, 0xfe, 0xb6, 0x0, 0x0, + + /* U+03B6 "ζ" */ + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x5, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x0, 0x14, 0x44, + 0x44, 0x8f, 0xfc, 0x20, 0x0, 0x0, 0x0, 0x7f, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x3, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xfa, 0x42, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0xeb, 0x50, + 0x0, 0x2e, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x29, 0xdf, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x2, 0xcf, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xf3, 0x0, 0x0, 0x0, 0x5, 0xaf, 0xfb, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xfc, 0x10, 0x0, 0x0, + 0x0, 0x6e, 0xc6, 0x0, 0x0, + + /* U+03B7 "η" */ + 0xdf, 0xb0, 0x18, 0xdf, 0xfd, 0x81, 0x0, 0xdf, + 0xb3, 0xef, 0xff, 0xff, 0xfe, 0x30, 0xdf, 0xde, + 0xfd, 0x87, 0x9e, 0xff, 0xe0, 0xdf, 0xff, 0x70, + 0x0, 0x1, 0xef, 0xf5, 0xdf, 0xfa, 0x0, 0x0, + 0x0, 0x7f, 0xf8, 0xdf, 0xf4, 0x0, 0x0, 0x0, + 0x4f, 0xf9, 0xdf, 0xf1, 0x0, 0x0, 0x0, 0x2f, + 0xfa, 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xfa, + 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xfa, 0xdf, + 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xfa, 0xdf, 0xf0, + 0x0, 0x0, 0x0, 0x2f, 0xfa, 0xdf, 0xf0, 0x0, + 0x0, 0x0, 0x2f, 0xfa, 0xdf, 0xf0, 0x0, 0x0, + 0x0, 0x2f, 0xfa, 0xdf, 0xf0, 0x0, 0x0, 0x0, + 0x2f, 0xfa, 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x2f, + 0xfa, 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xfa, + 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xfa, + + /* U+03B8 "θ" */ + 0x0, 0x0, 0x29, 0xdf, 0xed, 0x81, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xfe, 0x40, 0x0, + 0x0, 0x6f, 0xff, 0x96, 0x6b, 0xff, 0xf3, 0x0, + 0x1, 0xff, 0xf3, 0x0, 0x0, 0x5f, 0xfd, 0x0, + 0x7, 0xff, 0x70, 0x0, 0x0, 0x9, 0xff, 0x40, + 0xc, 0xff, 0x0, 0x0, 0x0, 0x3, 0xff, 0x90, + 0x1f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xef, 0xe0, + 0x4f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf0, + 0x6f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf3, + 0x7f, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x8f, 0xf8, 0x44, 0x44, 0x44, 0x44, 0xaf, 0xf5, + 0x7f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, + 0x6f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf3, + 0x4f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf1, + 0x1f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xff, 0xe0, + 0xd, 0xff, 0x10, 0x0, 0x0, 0x4, 0xff, 0x90, + 0x7, 0xff, 0x80, 0x0, 0x0, 0xb, 0xff, 0x40, + 0x1, 0xff, 0xf4, 0x0, 0x0, 0x7f, 0xfd, 0x0, + 0x0, 0x6f, 0xff, 0x95, 0x6b, 0xff, 0xf3, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x29, 0xdf, 0xfd, 0x81, 0x0, 0x0, + + /* U+03B9 "ι" */ + 0xdf, 0xfd, 0xff, 0xdf, 0xfd, 0xff, 0xdf, 0xfd, + 0xff, 0xdf, 0xfd, 0xff, 0xdf, 0xfd, 0xff, 0xdf, + 0xfd, 0xff, 0xdf, 0xfd, 0xff, 0xdf, 0xfd, 0xff, + 0xdf, 0xf0, + + /* U+03BA "κ" */ + 0xef, 0xe0, 0x0, 0x0, 0x1c, 0xff, 0xc0, 0xef, + 0xe0, 0x0, 0x1, 0xcf, 0xfb, 0x0, 0xef, 0xe0, + 0x0, 0x1d, 0xff, 0xa0, 0x0, 0xef, 0xe0, 0x1, + 0xdf, 0xfa, 0x0, 0x0, 0xef, 0xe0, 0x1d, 0xff, + 0x90, 0x0, 0x0, 0xef, 0xe1, 0xdf, 0xf8, 0x0, + 0x0, 0x0, 0xef, 0xed, 0xff, 0x80, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, 0xef, + 0xf6, 0xaf, 0xfd, 0x0, 0x0, 0x0, 0xef, 0xe0, + 0xd, 0xff, 0xb0, 0x0, 0x0, 0xef, 0xe0, 0x2, + 0xef, 0xf8, 0x0, 0x0, 0xef, 0xe0, 0x0, 0x4f, + 0xff, 0x50, 0x0, 0xef, 0xe0, 0x0, 0x7, 0xff, + 0xf2, 0x0, 0xef, 0xe0, 0x0, 0x0, 0xaf, 0xfd, + 0x10, 0xef, 0xe0, 0x0, 0x0, 0xc, 0xff, 0xb0, + 0xef, 0xe0, 0x0, 0x0, 0x1, 0xef, 0xf9, + + /* U+03BB "λ" */ + 0x0, 0x0, 0xcf, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xfa, 0xaf, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xf4, 0x4f, 0xfa, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xe0, 0xe, 0xff, 0x10, 0x0, + 0x0, 0x6, 0xff, 0x80, 0x8, 0xff, 0x60, 0x0, + 0x0, 0xc, 0xff, 0x20, 0x2, 0xff, 0xc0, 0x0, + 0x0, 0x2f, 0xfc, 0x0, 0x0, 0xcf, 0xf2, 0x0, + 0x0, 0x8f, 0xf6, 0x0, 0x0, 0x6f, 0xf8, 0x0, + 0x0, 0xef, 0xf0, 0x0, 0x0, 0x1f, 0xfe, 0x0, + 0x4, 0xff, 0xa0, 0x0, 0x0, 0xa, 0xff, 0x40, + 0xa, 0xff, 0x40, 0x0, 0x0, 0x4, 0xff, 0xa0, + 0x1f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf1, + 0x7f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf6, + + /* U+03BC "μ" */ + 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xf9, 0xdf, + 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xf9, 0xdf, 0xf0, + 0x0, 0x0, 0x0, 0x2f, 0xf9, 0xdf, 0xf0, 0x0, + 0x0, 0x0, 0x2f, 0xf9, 0xdf, 0xf0, 0x0, 0x0, + 0x0, 0x2f, 0xf9, 0xdf, 0xf0, 0x0, 0x0, 0x0, + 0x2f, 0xf9, 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x2f, + 0xf9, 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xf9, + 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x3f, 0xf9, 0xdf, + 0xf0, 0x0, 0x0, 0x0, 0x3f, 0xf9, 0xdf, 0xf1, + 0x0, 0x0, 0x0, 0x4f, 0xf9, 0xdf, 0xf4, 0x0, + 0x0, 0x0, 0x7f, 0xf9, 0xdf, 0xfa, 0x0, 0x0, + 0x0, 0xdf, 0xf9, 0xdf, 0xff, 0x60, 0x0, 0xa, + 0xff, 0xf9, 0xdf, 0xff, 0xfd, 0x9a, 0xef, 0xff, + 0xf9, 0xdf, 0xf9, 0xff, 0xff, 0xff, 0x6e, 0xf9, + 0xdf, 0xf0, 0x5c, 0xfe, 0xb4, 0xe, 0xf9, 0xdf, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+03BD "ν" */ + 0x6f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf7, + 0x1f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf1, + 0xa, 0xff, 0x30, 0x0, 0x0, 0x2, 0xff, 0xb0, + 0x4, 0xff, 0x90, 0x0, 0x0, 0x8, 0xff, 0x50, + 0x0, 0xef, 0xe0, 0x0, 0x0, 0xd, 0xfe, 0x0, + 0x0, 0x8f, 0xf4, 0x0, 0x0, 0x3f, 0xf9, 0x0, + 0x0, 0x2f, 0xfa, 0x0, 0x0, 0x9f, 0xf3, 0x0, + 0x0, 0xc, 0xff, 0x0, 0x0, 0xef, 0xd0, 0x0, + 0x0, 0x7, 0xff, 0x50, 0x4, 0xff, 0x70, 0x0, + 0x0, 0x1, 0xff, 0xb0, 0xa, 0xff, 0x10, 0x0, + 0x0, 0x0, 0xbf, 0xf0, 0xf, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xf5, 0x5f, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xfa, 0xaf, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xf8, 0x0, 0x0, 0x0, + + /* U+03BE "ξ" */ + 0x0, 0x0, 0x6b, 0xdf, 0xff, 0xf1, 0x0, 0x2, + 0xdf, 0xff, 0xff, 0xff, 0x10, 0x1, 0xef, 0xfc, + 0x86, 0x55, 0x50, 0x0, 0x8f, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xe6, 0x20, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x1, 0x7e, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x2c, 0xff, 0xe9, 0x75, + 0x0, 0x0, 0x3f, 0xfe, 0x60, 0x0, 0x0, 0x0, + 0x2f, 0xfe, 0x30, 0x0, 0x0, 0x0, 0xb, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x2, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xb6, 0x31, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xfd, 0x80, + 0x0, 0x0, 0x4b, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x36, 0xaf, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xf7, 0x0, 0x0, 0x0, 0xa, 0xdf, 0xfe, 0x10, + 0x0, 0x0, 0x2, 0xff, 0xfe, 0x20, 0x0, 0x0, + 0x0, 0x6e, 0xc7, 0x0, 0x0, + + /* U+03BF "ο" */ + 0x0, 0x0, 0x4a, 0xdf, 0xfd, 0x93, 0x0, 0x0, + 0x0, 0x1b, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x1, 0xef, 0xfe, 0x85, 0x69, 0xff, 0xfb, 0x0, + 0xb, 0xff, 0xc1, 0x0, 0x0, 0x2e, 0xff, 0x70, + 0x3f, 0xfe, 0x10, 0x0, 0x0, 0x3, 0xff, 0xe0, + 0x8f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf4, + 0xbf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf8, + 0xcf, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf9, + 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfa, + 0xcf, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf9, + 0xbf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf7, + 0x8f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf4, + 0x3f, 0xfe, 0x10, 0x0, 0x0, 0x3, 0xff, 0xe0, + 0xb, 0xff, 0xb1, 0x0, 0x0, 0x2d, 0xff, 0x70, + 0x1, 0xef, 0xfe, 0x85, 0x59, 0xff, 0xfb, 0x0, + 0x0, 0x1c, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x4a, 0xef, 0xfd, 0x93, 0x0, 0x0, + + /* U+03C0 "π" */ + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf6, 0x4f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x14, 0x44, + 0x4f, 0xfe, 0x44, 0x44, 0x44, 0x6f, 0xfb, 0x44, + 0x41, 0x0, 0x0, 0xe, 0xfe, 0x0, 0x0, 0x0, + 0x3f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xe, 0xfe, + 0x0, 0x0, 0x0, 0x3f, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xfe, 0x0, 0x0, 0x0, 0x3f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xfe, 0x0, 0x0, + 0x0, 0x3f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xfe, 0x0, 0x0, 0x0, 0x3f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xfe, 0x0, 0x0, 0x0, 0x3f, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0xe, 0xfe, 0x0, + 0x0, 0x0, 0x3f, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xfe, 0x0, 0x0, 0x0, 0x3f, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xfe, 0x0, 0x0, 0x0, + 0x3f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xe, 0xfe, + 0x0, 0x0, 0x0, 0x3f, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xfe, 0x0, 0x0, 0x0, 0x3f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xfe, 0x0, 0x0, + 0x0, 0x3f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xfe, 0x0, 0x0, 0x0, 0x3f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xfe, 0x0, 0x0, 0x0, 0x3f, + 0xf9, 0x0, 0x0, + + /* U+03C1 "ρ" */ + 0x0, 0x1, 0x8c, 0xef, 0xeb, 0x50, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xfd, 0x20, 0x0, + 0x4, 0xff, 0xfc, 0x75, 0x7d, 0xff, 0xe1, 0x0, + 0xd, 0xff, 0x70, 0x0, 0x0, 0x9f, 0xfc, 0x0, + 0x4f, 0xfb, 0x0, 0x0, 0x0, 0xb, 0xff, 0x40, + 0x9f, 0xf5, 0x0, 0x0, 0x0, 0x4, 0xff, 0xa0, + 0xcf, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xff, 0xe0, + 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf0, + 0xef, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf0, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf0, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xe0, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x4, 0xff, 0xa0, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0xb, 0xff, 0x50, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x8f, 0xfd, 0x0, + 0xff, 0xff, 0xfb, 0x65, 0x7c, 0xff, 0xf2, 0x0, + 0xff, 0xd9, 0xff, 0xff, 0xff, 0xfe, 0x30, 0x0, + 0xff, 0xd0, 0x4a, 0xef, 0xec, 0x70, 0x0, 0x0, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03C2 "ς" */ + 0x0, 0x0, 0x0, 0x6a, 0xdf, 0xfe, 0xc9, 0x0, + 0x0, 0x7, 0xef, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0xa, 0xff, 0xfb, 0x75, 0x57, 0xa7, 0x0, 0xa, + 0xff, 0xb2, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xc2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1d, 0xff, 0xfa, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x1b, 0xff, 0xff, 0xfc, 0x60, 0x0, + 0x0, 0x0, 0x4, 0xaf, 0xff, 0xff, 0xe3, 0x0, + 0x0, 0x0, 0x0, 0x3, 0x7d, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x20, 0x0, 0x0, + 0x6, 0xba, 0xdf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xeb, 0x50, 0x0, 0x0, + + /* U+03C3 "σ" */ + 0x0, 0x0, 0x4a, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x0, 0x1, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf0, 0x1, 0xef, 0xfe, 0x85, 0x69, + 0xff, 0xfd, 0x44, 0x44, 0x0, 0xcf, 0xfb, 0x0, + 0x0, 0x2, 0xef, 0xf7, 0x0, 0x0, 0x4f, 0xfd, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xe0, 0x0, 0x9, + 0xff, 0x60, 0x0, 0x0, 0x0, 0xc, 0xff, 0x40, + 0x0, 0xcf, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xf7, 0x0, 0xd, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0x80, 0x0, 0xef, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xf9, 0x0, 0xd, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0x80, 0x0, 0xcf, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf6, 0x0, + 0x8, 0xff, 0x60, 0x0, 0x0, 0x0, 0xb, 0xff, + 0x30, 0x0, 0x3f, 0xfd, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xe0, 0x0, 0x0, 0xcf, 0xfa, 0x0, 0x0, + 0x2, 0xef, 0xf6, 0x0, 0x0, 0x1, 0xef, 0xfd, + 0x75, 0x69, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x2, + 0xcf, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5a, 0xef, 0xfd, 0x82, 0x0, 0x0, + 0x0, 0x0, + + /* U+03C4 "τ" */ + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x4f, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x14, 0x44, 0x4e, 0xfe, + 0x44, 0x44, 0x0, 0x0, 0xe, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xe, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xe, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xe, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xfe, 0x0, 0x0, + + /* U+03C5 "υ" */ + 0xef, 0xf0, 0x0, 0x0, 0x0, 0x6f, 0xf6, 0xef, + 0xf0, 0x0, 0x0, 0x0, 0x6f, 0xf6, 0xef, 0xf0, + 0x0, 0x0, 0x0, 0x6f, 0xf6, 0xef, 0xf0, 0x0, + 0x0, 0x0, 0x6f, 0xf6, 0xef, 0xf0, 0x0, 0x0, + 0x0, 0x6f, 0xf6, 0xef, 0xf0, 0x0, 0x0, 0x0, + 0x6f, 0xf6, 0xef, 0xf0, 0x0, 0x0, 0x0, 0x6f, + 0xf6, 0xef, 0xf0, 0x0, 0x0, 0x0, 0x6f, 0xf6, + 0xef, 0xf0, 0x0, 0x0, 0x0, 0x6f, 0xf6, 0xdf, + 0xf0, 0x0, 0x0, 0x0, 0x6f, 0xf6, 0xdf, 0xf0, + 0x0, 0x0, 0x0, 0x7f, 0xf5, 0xcf, 0xf1, 0x0, + 0x0, 0x0, 0x9f, 0xf4, 0x9f, 0xf6, 0x0, 0x0, + 0x0, 0xdf, 0xf0, 0x4f, 0xfe, 0x20, 0x0, 0x9, + 0xff, 0xb0, 0xa, 0xff, 0xf8, 0x56, 0xcf, 0xff, + 0x20, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xe4, 0x0, + 0x0, 0x5, 0xbe, 0xff, 0xc8, 0x10, 0x0, + + /* U+03C6 "φ" */ + 0x0, 0x0, 0x7d, 0xa0, 0x7, 0xdf, 0xec, 0x70, + 0x0, 0x0, 0x2, 0xef, 0xf7, 0x6, 0xff, 0xff, + 0xff, 0xe2, 0x0, 0x1, 0xef, 0xfc, 0x20, 0xcf, + 0xfb, 0x5a, 0xff, 0xe0, 0x0, 0xbf, 0xf8, 0x0, + 0xd, 0xff, 0x0, 0x7, 0xff, 0x80, 0x3f, 0xfc, + 0x0, 0x0, 0xef, 0xe0, 0x0, 0xd, 0xfe, 0x8, + 0xff, 0x50, 0x0, 0xe, 0xfe, 0x0, 0x0, 0x8f, + 0xf5, 0xbf, 0xf2, 0x0, 0x0, 0xef, 0xe0, 0x0, + 0x5, 0xff, 0x7d, 0xff, 0x0, 0x0, 0xe, 0xfe, + 0x0, 0x0, 0x5f, 0xf9, 0xdf, 0xf0, 0x0, 0x0, + 0xef, 0xe0, 0x0, 0x5, 0xff, 0x9c, 0xff, 0x20, + 0x0, 0xe, 0xfe, 0x0, 0x0, 0x8f, 0xf7, 0x9f, + 0xf7, 0x0, 0x0, 0xef, 0xe0, 0x0, 0xc, 0xff, + 0x24, 0xff, 0xd0, 0x0, 0xe, 0xfe, 0x0, 0x3, + 0xff, 0xd0, 0xc, 0xff, 0x80, 0x0, 0xef, 0xe0, + 0x1, 0xdf, 0xf4, 0x0, 0x3f, 0xff, 0x80, 0xe, + 0xfe, 0x2, 0xcf, 0xfa, 0x0, 0x0, 0x5f, 0xff, + 0xe9, 0xff, 0xfb, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x4e, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xcf, 0xff, 0xfd, 0x82, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xe0, 0x0, + 0x0, 0x0, 0x0, + + /* U+03C7 "χ" */ + 0xe, 0xff, 0x10, 0x0, 0x0, 0x0, 0x2f, 0xfe, + 0x0, 0x7f, 0xf8, 0x0, 0x0, 0x0, 0xa, 0xff, + 0x60, 0x0, 0xef, 0xf1, 0x0, 0x0, 0x3, 0xff, + 0xd0, 0x0, 0x7, 0xff, 0x80, 0x0, 0x0, 0xbf, + 0xf4, 0x0, 0x0, 0xe, 0xff, 0x10, 0x0, 0x3f, + 0xfc, 0x0, 0x0, 0x0, 0x6f, 0xf8, 0x0, 0xb, + 0xff, 0x30, 0x0, 0x0, 0x0, 0xdf, 0xf1, 0x3, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x5, 0xff, 0x80, + 0xcf, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0x5f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xfd, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xfc, 0x1f, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0x40, 0x8f, 0xf6, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xc0, 0x1, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0xbf, 0xf4, 0x0, 0x8, 0xff, 0x70, + 0x0, 0x0, 0x4f, 0xfb, 0x0, 0x0, 0x1f, 0xff, + 0x10, 0x0, 0xc, 0xff, 0x30, 0x0, 0x0, 0x8f, + 0xf9, 0x0, 0x5, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0xef, 0xf2, 0x0, 0xef, 0xf3, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xa0, 0x7f, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0x30, + + /* U+03C8 "ψ" */ + 0x1f, 0xfb, 0x0, 0x0, 0xf, 0xfd, 0x0, 0x0, + 0xe, 0xfe, 0x1f, 0xfb, 0x0, 0x0, 0xf, 0xfd, + 0x0, 0x0, 0xe, 0xfe, 0x1f, 0xfb, 0x0, 0x0, + 0xf, 0xfd, 0x0, 0x0, 0xe, 0xfe, 0x1f, 0xfb, + 0x0, 0x0, 0xf, 0xfd, 0x0, 0x0, 0xe, 0xfe, + 0x1f, 0xfb, 0x0, 0x0, 0xf, 0xfd, 0x0, 0x0, + 0xe, 0xfe, 0x1f, 0xfb, 0x0, 0x0, 0xf, 0xfd, + 0x0, 0x0, 0xe, 0xfe, 0x1f, 0xfb, 0x0, 0x0, + 0xf, 0xfd, 0x0, 0x0, 0xe, 0xfe, 0x1f, 0xfb, + 0x0, 0x0, 0xf, 0xfd, 0x0, 0x0, 0xe, 0xfe, + 0x1f, 0xfb, 0x0, 0x0, 0xf, 0xfd, 0x0, 0x0, + 0xe, 0xfe, 0x1f, 0xfb, 0x0, 0x0, 0xf, 0xfd, + 0x0, 0x0, 0xf, 0xfd, 0xf, 0xfd, 0x0, 0x0, + 0xf, 0xfd, 0x0, 0x0, 0xf, 0xfc, 0xe, 0xff, + 0x0, 0x0, 0xf, 0xfd, 0x0, 0x0, 0x3f, 0xfa, + 0xa, 0xff, 0x70, 0x0, 0xf, 0xfd, 0x0, 0x0, + 0xaf, 0xf6, 0x3, 0xff, 0xf5, 0x0, 0xf, 0xfd, + 0x0, 0x8, 0xff, 0xf1, 0x0, 0x7f, 0xff, 0xd8, + 0x6f, 0xfe, 0x68, 0xef, 0xff, 0x50, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe5, 0x0, + 0x0, 0x0, 0x17, 0xbe, 0xff, 0xff, 0xfe, 0xb7, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xfd, 0x0, 0x0, 0x0, 0x0, + + /* U+03C9 "ω" */ + 0x0, 0x6f, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0x60, 0x0, 0xe, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xfd, 0x0, 0x5, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf5, 0x0, 0xbf, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xb0, 0x1f, 0xfe, + 0x0, 0x0, 0x0, 0xbc, 0xb0, 0x0, 0x0, 0xe, + 0xff, 0x4, 0xff, 0xa0, 0x0, 0x0, 0xe, 0xfe, + 0x0, 0x0, 0x0, 0xaf, 0xf4, 0x7f, 0xf6, 0x0, + 0x0, 0x0, 0xef, 0xe0, 0x0, 0x0, 0x7, 0xff, + 0x79, 0xff, 0x40, 0x0, 0x0, 0xe, 0xfe, 0x0, + 0x0, 0x0, 0x5f, 0xf8, 0xaf, 0xf3, 0x0, 0x0, + 0x0, 0xef, 0xe0, 0x0, 0x0, 0x4, 0xff, 0x99, + 0xff, 0x40, 0x0, 0x0, 0xe, 0xfe, 0x0, 0x0, + 0x0, 0x4f, 0xf9, 0x8f, 0xf5, 0x0, 0x0, 0x0, + 0xff, 0xf0, 0x0, 0x0, 0x6, 0xff, 0x75, 0xff, + 0x90, 0x0, 0x0, 0x1f, 0xff, 0x10, 0x0, 0x0, + 0x9f, 0xf5, 0x1f, 0xfe, 0x0, 0x0, 0x5, 0xff, + 0xf5, 0x0, 0x0, 0xe, 0xff, 0x10, 0xbf, 0xf7, + 0x0, 0x1, 0xdf, 0xbf, 0xd0, 0x0, 0x8, 0xff, + 0xb0, 0x2, 0xff, 0xf9, 0x35, 0xdf, 0xd0, 0xdf, + 0xd5, 0x39, 0xff, 0xf2, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xe2, 0x2, 0xef, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x2, 0xae, 0xfd, 0x81, 0x0, 0x1, 0x9d, + 0xfe, 0xa2, 0x0, 0x0, + + /* U+03CA "ϊ" */ + 0xdf, 0xf1, 0x0, 0xff, 0xed, 0xff, 0x10, 0xf, + 0xfe, 0xdf, 0xf1, 0x0, 0xff, 0xe3, 0x33, 0x0, + 0x3, 0x33, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0x0, 0x0, + 0x0, 0xdf, 0xf0, 0x0, 0x0, 0xd, 0xff, 0x0, + 0x0, 0x0, 0xdf, 0xf0, 0x0, 0x0, 0xd, 0xff, + 0x0, 0x0, 0x0, 0xdf, 0xf0, 0x0, 0x0, 0xd, + 0xff, 0x0, 0x0, 0x0, 0xdf, 0xf0, 0x0, 0x0, + 0xd, 0xff, 0x0, 0x0, 0x0, 0xdf, 0xf0, 0x0, + 0x0, 0xd, 0xff, 0x0, 0x0, 0x0, 0xdf, 0xf0, + 0x0, 0x0, 0xd, 0xff, 0x0, 0x0, 0x0, 0xdf, + 0xf0, 0x0, 0x0, 0xd, 0xff, 0x0, 0x0, 0x0, + 0xdf, 0xf0, 0x0, 0x0, 0xd, 0xff, 0x0, 0x0, + + /* U+03CB "ϋ" */ + 0x0, 0xaf, 0xf5, 0x0, 0xcf, 0xf2, 0x0, 0x0, + 0xaf, 0xf5, 0x0, 0xcf, 0xf2, 0x0, 0x0, 0xaf, + 0xf5, 0x0, 0xcf, 0xf2, 0x0, 0x0, 0x23, 0x31, + 0x0, 0x23, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xf0, 0x0, 0x0, 0x0, 0x6f, + 0xf6, 0xef, 0xf0, 0x0, 0x0, 0x0, 0x6f, 0xf6, + 0xef, 0xf0, 0x0, 0x0, 0x0, 0x6f, 0xf6, 0xef, + 0xf0, 0x0, 0x0, 0x0, 0x6f, 0xf6, 0xef, 0xf0, + 0x0, 0x0, 0x0, 0x6f, 0xf6, 0xef, 0xf0, 0x0, + 0x0, 0x0, 0x6f, 0xf6, 0xef, 0xf0, 0x0, 0x0, + 0x0, 0x6f, 0xf6, 0xef, 0xf0, 0x0, 0x0, 0x0, + 0x6f, 0xf6, 0xef, 0xf0, 0x0, 0x0, 0x0, 0x6f, + 0xf6, 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x6f, 0xf6, + 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x7f, 0xf5, 0xcf, + 0xf1, 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x9f, 0xf6, + 0x0, 0x0, 0x0, 0xdf, 0xf0, 0x4f, 0xfe, 0x20, + 0x0, 0x9, 0xff, 0xb0, 0xa, 0xff, 0xf8, 0x56, + 0xcf, 0xff, 0x20, 0x0, 0xaf, 0xff, 0xff, 0xff, + 0xe4, 0x0, 0x0, 0x5, 0xbe, 0xff, 0xc8, 0x10, + 0x0, + + /* U+03CC "ό" */ + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xe2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x56, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4a, 0xdf, 0xfd, 0x93, 0x0, 0x0, + 0x0, 0x1b, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x1, 0xef, 0xfe, 0x85, 0x69, 0xff, 0xfb, 0x0, + 0xb, 0xff, 0xc1, 0x0, 0x0, 0x2e, 0xff, 0x70, + 0x3f, 0xfe, 0x10, 0x0, 0x0, 0x3, 0xff, 0xe0, + 0x8f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf4, + 0xbf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf8, + 0xcf, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf9, + 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfa, + 0xcf, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf9, + 0xbf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf7, + 0x8f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf4, + 0x3f, 0xfe, 0x10, 0x0, 0x0, 0x3, 0xff, 0xe0, + 0xb, 0xff, 0xb1, 0x0, 0x0, 0x2d, 0xff, 0x70, + 0x1, 0xef, 0xfe, 0x85, 0x59, 0xff, 0xfb, 0x0, + 0x0, 0x1c, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x4a, 0xef, 0xfd, 0x93, 0x0, 0x0, + + /* U+03CD "ύ" */ + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x6, 0x62, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xf0, 0x0, 0x0, 0x0, 0x6f, 0xf6, + 0xef, 0xf0, 0x0, 0x0, 0x0, 0x6f, 0xf6, 0xef, + 0xf0, 0x0, 0x0, 0x0, 0x6f, 0xf6, 0xef, 0xf0, + 0x0, 0x0, 0x0, 0x6f, 0xf6, 0xef, 0xf0, 0x0, + 0x0, 0x0, 0x6f, 0xf6, 0xef, 0xf0, 0x0, 0x0, + 0x0, 0x6f, 0xf6, 0xef, 0xf0, 0x0, 0x0, 0x0, + 0x6f, 0xf6, 0xef, 0xf0, 0x0, 0x0, 0x0, 0x6f, + 0xf6, 0xef, 0xf0, 0x0, 0x0, 0x0, 0x6f, 0xf6, + 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x6f, 0xf6, 0xdf, + 0xf0, 0x0, 0x0, 0x0, 0x7f, 0xf5, 0xcf, 0xf1, + 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x9f, 0xf6, 0x0, + 0x0, 0x0, 0xdf, 0xf0, 0x4f, 0xfe, 0x20, 0x0, + 0x9, 0xff, 0xb0, 0xa, 0xff, 0xf8, 0x56, 0xcf, + 0xff, 0x20, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xe4, + 0x0, 0x0, 0x5, 0xbe, 0xff, 0xc8, 0x10, 0x0, + + /* U+03CE "ώ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x66, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xf6, 0x0, 0x0, 0xef, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xd0, 0x0, + 0x5f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0x50, 0xb, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfb, 0x1, 0xff, + 0xe0, 0x0, 0x0, 0xb, 0xcb, 0x0, 0x0, 0x0, + 0xef, 0xf0, 0x4f, 0xfa, 0x0, 0x0, 0x0, 0xef, + 0xe0, 0x0, 0x0, 0xa, 0xff, 0x47, 0xff, 0x60, + 0x0, 0x0, 0xe, 0xfe, 0x0, 0x0, 0x0, 0x7f, + 0xf7, 0x9f, 0xf4, 0x0, 0x0, 0x0, 0xef, 0xe0, + 0x0, 0x0, 0x5, 0xff, 0x8a, 0xff, 0x30, 0x0, + 0x0, 0xe, 0xfe, 0x0, 0x0, 0x0, 0x4f, 0xf9, + 0x9f, 0xf4, 0x0, 0x0, 0x0, 0xef, 0xe0, 0x0, + 0x0, 0x4, 0xff, 0x98, 0xff, 0x50, 0x0, 0x0, + 0xf, 0xff, 0x0, 0x0, 0x0, 0x6f, 0xf7, 0x5f, + 0xf9, 0x0, 0x0, 0x1, 0xff, 0xf1, 0x0, 0x0, + 0x9, 0xff, 0x51, 0xff, 0xe0, 0x0, 0x0, 0x5f, + 0xff, 0x50, 0x0, 0x0, 0xef, 0xf1, 0xb, 0xff, + 0x70, 0x0, 0x1d, 0xfb, 0xfd, 0x0, 0x0, 0x8f, + 0xfb, 0x0, 0x2f, 0xff, 0x93, 0x5d, 0xfd, 0xd, + 0xfd, 0x53, 0x9f, 0xff, 0x20, 0x0, 0x5f, 0xff, + 0xff, 0xfe, 0x20, 0x2e, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x2a, 0xef, 0xd8, 0x10, 0x0, 0x19, + 0xdf, 0xea, 0x20, 0x0, + + /* U+03F4 "ϴ" */ + 0x0, 0x0, 0x0, 0x58, 0x71, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xfa, 0x0, 0x0, 0x5f, 0xf5, 0x7, + 0xfe, 0xb, 0xff, 0x5, 0xff, 0x50, 0xef, 0x40, + 0xbf, 0xf0, 0x5f, 0xf5, 0x6f, 0x80, 0xb, 0xff, + 0x0 +}; + + +/*--------------------- + * GLYPH DESCRIPTION + *--------------------*/ + +static const lv_font_fmt_txt_glyph_dsc_t glyph_dsc[] = { + {.bitmap_index = 0, .adv_w = 0, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0} /* id = 0 reserved */, + {.bitmap_index = 0, .adv_w = 142, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 0, .adv_w = 143, .box_w = 5, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 58, .adv_w = 182, .box_w = 9, .box_h = 9, .ofs_x = 1, .ofs_y = 14}, + {.bitmap_index = 99, .adv_w = 285, .box_w = 18, .box_h = 23, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 306, .adv_w = 285, .box_w = 16, .box_h = 29, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 538, .adv_w = 455, .box_w = 26, .box_h = 23, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 837, .adv_w = 342, .box_w = 20, .box_h = 24, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 1077, .adv_w = 97, .box_w = 4, .box_h = 9, .ofs_x = 1, .ofs_y = 14}, + {.bitmap_index = 1095, .adv_w = 171, .box_w = 9, .box_h = 29, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 1226, .adv_w = 171, .box_w = 8, .box_h = 29, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 1342, .adv_w = 199, .box_w = 11, .box_h = 10, .ofs_x = 1, .ofs_y = 13}, + {.bitmap_index = 1397, .adv_w = 299, .box_w = 16, .box_h = 16, .ofs_x = 1, .ofs_y = 4}, + {.bitmap_index = 1525, .adv_w = 143, .box_w = 4, .box_h = 9, .ofs_x = 2, .ofs_y = -5}, + {.bitmap_index = 1543, .adv_w = 171, .box_w = 9, .box_h = 3, .ofs_x = 1, .ofs_y = 7}, + {.bitmap_index = 1557, .adv_w = 143, .box_w = 5, .box_h = 4, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 1567, .adv_w = 142, .box_w = 9, .box_h = 23, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1671, .adv_w = 285, .box_w = 16, .box_h = 23, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1855, .adv_w = 285, .box_w = 9, .box_h = 23, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 1959, .adv_w = 285, .box_w = 16, .box_h = 23, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2143, .adv_w = 285, .box_w = 16, .box_h = 23, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2327, .adv_w = 285, .box_w = 17, .box_h = 23, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2523, .adv_w = 285, .box_w = 16, .box_h = 23, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2707, .adv_w = 285, .box_w = 16, .box_h = 23, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2891, .adv_w = 285, .box_w = 16, .box_h = 23, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3075, .adv_w = 285, .box_w = 16, .box_h = 23, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3259, .adv_w = 285, .box_w = 16, .box_h = 23, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3443, .adv_w = 143, .box_w = 5, .box_h = 17, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 3486, .adv_w = 143, .box_w = 4, .box_h = 22, .ofs_x = 2, .ofs_y = -5}, + {.bitmap_index = 3530, .adv_w = 299, .box_w = 16, .box_h = 17, .ofs_x = 1, .ofs_y = 3}, + {.bitmap_index = 3666, .adv_w = 299, .box_w = 16, .box_h = 10, .ofs_x = 1, .ofs_y = 7}, + {.bitmap_index = 3746, .adv_w = 299, .box_w = 16, .box_h = 17, .ofs_x = 1, .ofs_y = 3}, + {.bitmap_index = 3882, .adv_w = 285, .box_w = 16, .box_h = 23, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4066, .adv_w = 520, .box_w = 31, .box_h = 29, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 4516, .adv_w = 342, .box_w = 23, .box_h = 23, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 4781, .adv_w = 342, .box_w = 18, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 4988, .adv_w = 370, .box_w = 21, .box_h = 23, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 5230, .adv_w = 370, .box_w = 20, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 5460, .adv_w = 342, .box_w = 18, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 5667, .adv_w = 314, .box_w = 17, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 5863, .adv_w = 398, .box_w = 22, .box_h = 23, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 6116, .adv_w = 370, .box_w = 19, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 6335, .adv_w = 143, .box_w = 4, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 6381, .adv_w = 256, .box_w = 14, .box_h = 23, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6542, .adv_w = 342, .box_w = 20, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 6772, .adv_w = 285, .box_w = 15, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 6945, .adv_w = 427, .box_w = 23, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 7210, .adv_w = 370, .box_w = 19, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 7429, .adv_w = 398, .box_w = 23, .box_h = 23, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 7694, .adv_w = 342, .box_w = 18, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 7901, .adv_w = 398, .box_w = 23, .box_h = 25, .ofs_x = 1, .ofs_y = -2}, + {.bitmap_index = 8189, .adv_w = 370, .box_w = 21, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 8431, .adv_w = 342, .box_w = 19, .box_h = 23, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 8650, .adv_w = 314, .box_w = 19, .box_h = 23, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 8869, .adv_w = 370, .box_w = 19, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 9088, .adv_w = 342, .box_w = 22, .box_h = 23, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 9341, .adv_w = 483, .box_w = 30, .box_h = 23, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 9686, .adv_w = 342, .box_w = 22, .box_h = 23, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 9939, .adv_w = 342, .box_w = 22, .box_h = 23, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 10192, .adv_w = 314, .box_w = 19, .box_h = 23, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 10411, .adv_w = 143, .box_w = 7, .box_h = 29, .ofs_x = 2, .ofs_y = -6}, + {.bitmap_index = 10513, .adv_w = 142, .box_w = 9, .box_h = 23, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 10617, .adv_w = 143, .box_w = 7, .box_h = 29, .ofs_x = 0, .ofs_y = -6}, + {.bitmap_index = 10719, .adv_w = 240, .box_w = 15, .box_h = 13, .ofs_x = 0, .ofs_y = 11}, + {.bitmap_index = 10817, .adv_w = 285, .box_w = 19, .box_h = 3, .ofs_x = -1, .ofs_y = -6}, + {.bitmap_index = 10846, .adv_w = 171, .box_w = 7, .box_h = 5, .ofs_x = 1, .ofs_y = 19}, + {.bitmap_index = 10864, .adv_w = 285, .box_w = 16, .box_h = 17, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 11000, .adv_w = 285, .box_w = 15, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 11173, .adv_w = 256, .box_w = 15, .box_h = 17, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 11301, .adv_w = 285, .box_w = 15, .box_h = 23, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 11474, .adv_w = 285, .box_w = 16, .box_h = 17, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 11610, .adv_w = 143, .box_w = 10, .box_h = 23, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 11725, .adv_w = 285, .box_w = 15, .box_h = 23, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 11898, .adv_w = 285, .box_w = 14, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 12059, .adv_w = 114, .box_w = 3, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 12094, .adv_w = 114, .box_w = 7, .box_h = 29, .ofs_x = -2, .ofs_y = -6}, + {.bitmap_index = 12196, .adv_w = 256, .box_w = 14, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 12357, .adv_w = 114, .box_w = 3, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 12392, .adv_w = 427, .box_w = 23, .box_h = 17, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 12588, .adv_w = 285, .box_w = 14, .box_h = 17, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 12707, .adv_w = 285, .box_w = 16, .box_h = 17, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 12843, .adv_w = 285, .box_w = 15, .box_h = 23, .ofs_x = 2, .ofs_y = -6}, + {.bitmap_index = 13016, .adv_w = 285, .box_w = 15, .box_h = 23, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 13189, .adv_w = 171, .box_w = 10, .box_h = 17, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 13274, .adv_w = 256, .box_w = 15, .box_h = 17, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 13402, .adv_w = 143, .box_w = 9, .box_h = 23, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 13506, .adv_w = 285, .box_w = 14, .box_h = 17, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 13625, .adv_w = 256, .box_w = 16, .box_h = 17, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 13761, .adv_w = 370, .box_w = 23, .box_h = 17, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 13957, .adv_w = 256, .box_w = 16, .box_h = 17, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 14093, .adv_w = 256, .box_w = 16, .box_h = 23, .ofs_x = 0, .ofs_y = -6}, + {.bitmap_index = 14277, .adv_w = 256, .box_w = 16, .box_h = 17, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 14413, .adv_w = 171, .box_w = 10, .box_h = 29, .ofs_x = 0, .ofs_y = -6}, + {.bitmap_index = 14558, .adv_w = 133, .box_w = 4, .box_h = 29, .ofs_x = 2, .ofs_y = -6}, + {.bitmap_index = 14616, .adv_w = 171, .box_w = 10, .box_h = 29, .ofs_x = 0, .ofs_y = -6}, + {.bitmap_index = 14761, .adv_w = 299, .box_w = 17, .box_h = 7, .ofs_x = 1, .ofs_y = 8}, + {.bitmap_index = 14821, .adv_w = 142, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 14821, .adv_w = 285, .box_w = 17, .box_h = 24, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 15025, .adv_w = 285, .box_w = 16, .box_h = 17, .ofs_x = 1, .ofs_y = 3}, + {.bitmap_index = 15161, .adv_w = 285, .box_w = 18, .box_h = 23, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 15368, .adv_w = 133, .box_w = 4, .box_h = 29, .ofs_x = 2, .ofs_y = -6}, + {.bitmap_index = 15426, .adv_w = 285, .box_w = 16, .box_h = 29, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 15658, .adv_w = 171, .box_w = 10, .box_h = 4, .ofs_x = 0, .ofs_y = 20}, + {.bitmap_index = 15678, .adv_w = 377, .box_w = 24, .box_h = 24, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 15966, .adv_w = 192, .box_w = 12, .box_h = 12, .ofs_x = 0, .ofs_y = 11}, + {.bitmap_index = 16038, .adv_w = 285, .box_w = 14, .box_h = 15, .ofs_x = 2, .ofs_y = 1}, + {.bitmap_index = 16143, .adv_w = 299, .box_w = 16, .box_h = 10, .ofs_x = 1, .ofs_y = 7}, + {.bitmap_index = 16223, .adv_w = 171, .box_w = 9, .box_h = 3, .ofs_x = 1, .ofs_y = 7}, + {.bitmap_index = 16237, .adv_w = 377, .box_w = 24, .box_h = 24, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 16525, .adv_w = 205, .box_w = 9, .box_h = 9, .ofs_x = 2, .ofs_y = 15}, + {.bitmap_index = 16566, .adv_w = 299, .box_w = 16, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 16726, .adv_w = 171, .box_w = 11, .box_h = 12, .ofs_x = 0, .ofs_y = 11}, + {.bitmap_index = 16792, .adv_w = 171, .box_w = 11, .box_h = 12, .ofs_x = 0, .ofs_y = 11}, + {.bitmap_index = 16858, .adv_w = 285, .box_w = 14, .box_h = 23, .ofs_x = 2, .ofs_y = -6}, + {.bitmap_index = 17019, .adv_w = 275, .box_w = 19, .box_h = 29, .ofs_x = -1, .ofs_y = -6}, + {.bitmap_index = 17295, .adv_w = 144, .box_w = 5, .box_h = 4, .ofs_x = 2, .ofs_y = 10}, + {.bitmap_index = 17305, .adv_w = 285, .box_w = 14, .box_h = 15, .ofs_x = 2, .ofs_y = 1}, + {.bitmap_index = 17410, .adv_w = 427, .box_w = 26, .box_h = 25, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 17735, .adv_w = 171, .box_w = 7, .box_h = 5, .ofs_x = 3, .ofs_y = 19}, + {.bitmap_index = 17753, .adv_w = 342, .box_w = 23, .box_h = 23, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 18018, .adv_w = 402, .box_w = 26, .box_h = 23, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 18317, .adv_w = 429, .box_w = 26, .box_h = 23, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 18616, .adv_w = 197, .box_w = 11, .box_h = 23, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 18743, .adv_w = 397, .box_w = 26, .box_h = 23, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 19042, .adv_w = 438, .box_w = 29, .box_h = 23, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 19376, .adv_w = 385, .box_w = 25, .box_h = 23, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 19664, .adv_w = 114, .box_w = 13, .box_h = 24, .ofs_x = -3, .ofs_y = 0}, + {.bitmap_index = 19820, .adv_w = 342, .box_w = 23, .box_h = 23, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 20085, .adv_w = 342, .box_w = 18, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 20292, .adv_w = 282, .box_w = 15, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 20465, .adv_w = 342, .box_w = 23, .box_h = 23, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 20730, .adv_w = 342, .box_w = 18, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 20937, .adv_w = 314, .box_w = 19, .box_h = 23, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 21156, .adv_w = 370, .box_w = 19, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 21375, .adv_w = 398, .box_w = 23, .box_h = 23, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 21640, .adv_w = 143, .box_w = 4, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 21686, .adv_w = 342, .box_w = 20, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 21916, .adv_w = 342, .box_w = 22, .box_h = 23, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 22169, .adv_w = 427, .box_w = 23, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 22434, .adv_w = 370, .box_w = 19, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 22653, .adv_w = 333, .box_w = 19, .box_h = 23, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 22872, .adv_w = 398, .box_w = 23, .box_h = 23, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 23137, .adv_w = 370, .box_w = 19, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 23356, .adv_w = 342, .box_w = 18, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 23563, .adv_w = 317, .box_w = 17, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 23759, .adv_w = 314, .box_w = 19, .box_h = 23, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 23978, .adv_w = 342, .box_w = 22, .box_h = 23, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 24231, .adv_w = 409, .box_w = 24, .box_h = 25, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 24531, .adv_w = 342, .box_w = 22, .box_h = 23, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 24784, .adv_w = 428, .box_w = 24, .box_h = 23, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 25060, .adv_w = 383, .box_w = 22, .box_h = 23, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 25313, .adv_w = 143, .box_w = 10, .box_h = 28, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 25453, .adv_w = 342, .box_w = 22, .box_h = 28, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 25761, .adv_w = 296, .box_w = 17, .box_h = 24, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 25965, .adv_w = 228, .box_w = 13, .box_h = 24, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 26121, .adv_w = 285, .box_w = 14, .box_h = 30, .ofs_x = 2, .ofs_y = -6}, + {.bitmap_index = 26331, .adv_w = 114, .box_w = 7, .box_h = 24, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 26415, .adv_w = 280, .box_w = 14, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 26583, .adv_w = 296, .box_w = 17, .box_h = 17, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 26728, .adv_w = 295, .box_w = 15, .box_h = 29, .ofs_x = 2, .ofs_y = -6}, + {.bitmap_index = 26946, .adv_w = 256, .box_w = 16, .box_h = 23, .ofs_x = 0, .ofs_y = -6}, + {.bitmap_index = 27130, .adv_w = 285, .box_w = 16, .box_h = 23, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 27314, .adv_w = 228, .box_w = 13, .box_h = 17, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 27425, .adv_w = 226, .box_w = 13, .box_h = 29, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 27614, .adv_w = 285, .box_w = 14, .box_h = 23, .ofs_x = 2, .ofs_y = -6}, + {.bitmap_index = 27775, .adv_w = 285, .box_w = 16, .box_h = 23, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 27959, .adv_w = 114, .box_w = 3, .box_h = 17, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 27985, .adv_w = 255, .box_w = 14, .box_h = 17, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 28104, .adv_w = 256, .box_w = 16, .box_h = 23, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 28288, .adv_w = 285, .box_w = 14, .box_h = 23, .ofs_x = 2, .ofs_y = -6}, + {.bitmap_index = 28449, .adv_w = 256, .box_w = 16, .box_h = 17, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 28585, .adv_w = 229, .box_w = 13, .box_h = 29, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 28774, .adv_w = 285, .box_w = 16, .box_h = 17, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 28910, .adv_w = 353, .box_w = 22, .box_h = 17, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 29097, .adv_w = 291, .box_w = 16, .box_h = 23, .ofs_x = 2, .ofs_y = -6}, + {.bitmap_index = 29281, .adv_w = 247, .box_w = 15, .box_h = 23, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 29454, .adv_w = 316, .box_w = 19, .box_h = 17, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 29616, .adv_w = 202, .box_w = 12, .box_h = 17, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 29718, .adv_w = 280, .box_w = 14, .box_h = 17, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 29837, .adv_w = 332, .box_w = 19, .box_h = 23, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 30056, .adv_w = 269, .box_w = 17, .box_h = 23, .ofs_x = 0, .ofs_y = -6}, + {.bitmap_index = 30252, .adv_w = 365, .box_w = 20, .box_h = 23, .ofs_x = 1, .ofs_y = -6}, + {.bitmap_index = 30482, .adv_w = 400, .box_w = 23, .box_h = 17, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 30678, .adv_w = 114, .box_w = 9, .box_h = 23, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 30782, .adv_w = 280, .box_w = 14, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 30943, .adv_w = 285, .box_w = 16, .box_h = 24, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 31135, .adv_w = 280, .box_w = 14, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 31303, .adv_w = 400, .box_w = 23, .box_h = 24, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 31579, .adv_w = 171, .box_w = 13, .box_h = 5, .ofs_x = -1, .ofs_y = 19} +}; + +/*--------------------- + * CHARACTER MAPPING + *--------------------*/ + +static const uint8_t glyph_id_ofs_list_1[] = { + 0, 0, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 0, + 13, 14, 15, 16, 0, 17, 18, 19, + 0, 0, 0, 20, 0, 21 +}; + +static const uint8_t glyph_id_ofs_list_2[] = { + 0, 0, 1, 0, 2, 3, 4, 0, + 5 +}; + +/*Collect the unicode lists and glyph_id offsets*/ +static const lv_font_fmt_txt_cmap_t cmaps[] = +{ + { + .range_start = 32, .range_length = 95, .glyph_id_start = 1, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 160, .range_length = 30, .glyph_id_start = 96, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_1, .list_length = 30, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 900, .range_length = 9, .glyph_id_start = 118, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_2, .list_length = 9, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 910, .range_length = 20, .glyph_id_start = 124, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 931, .range_length = 44, .glyph_id_start = 144, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 1012, .range_length = 1, .glyph_id_start = 188, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + } +}; + + + +/*-------------------- + * ALL CUSTOM DATA + *--------------------*/ + +#if LVGL_VERSION_MAJOR == 8 +/*Store all the custom data of the font*/ +static lv_font_fmt_txt_glyph_cache_t cache; +#endif + +#if LVGL_VERSION_MAJOR >= 8 +static const lv_font_fmt_txt_dsc_t font_dsc = { +#else +static lv_font_fmt_txt_dsc_t font_dsc = { +#endif + .glyph_bitmap = glyph_bitmap, + .glyph_dsc = glyph_dsc, + .cmaps = cmaps, + .kern_dsc = NULL, + .kern_scale = 0, + .cmap_num = 6, + .bpp = 4, + .kern_classes = 0, + .bitmap_format = 0, +#if LVGL_VERSION_MAJOR == 8 + .cache = &cache +#endif + +}; + +extern const lv_font_t lv_font_montserrat_32; + + +/*----------------- + * PUBLIC FONT + *----------------*/ + +/*Initialize a public general font descriptor*/ +#if LVGL_VERSION_MAJOR >= 8 +const lv_font_t lv_font_arial_32 = { +#else +lv_font_t lv_font_arial_32 = { +#endif + .get_glyph_dsc = lv_font_get_glyph_dsc_fmt_txt, /*Function pointer to get glyph's data*/ + .get_glyph_bitmap = lv_font_get_bitmap_fmt_txt, /*Function pointer to get glyph's bitmap*/ + .line_height = 34, /*The maximum line height required by the font*/ + .base_line = 6, /*Baseline measured from the bottom of the line*/ +#if !(LVGL_VERSION_MAJOR == 6 && LVGL_VERSION_MINOR == 0) + .subpx = LV_FONT_SUBPX_NONE, +#endif +#if LV_VERSION_CHECK(7, 4, 0) || LVGL_VERSION_MAJOR >= 8 + .underline_position = -3, + .underline_thickness = 2, +#endif + //.static_bitmap = 0, + .dsc = &font_dsc, /*The custom font data. Will be accessed by `get_glyph_bitmap/dsc` */ +#if LV_VERSION_CHECK(8, 2, 0) || LVGL_VERSION_MAJOR >= 9 + .fallback = &lv_font_montserrat_32, +#endif + .user_data = NULL, +}; + + + +#endif /*#if LV_FONT_ARIAL_32*/ diff --git a/src/fonts/lv_font_arial_34.c b/src/fonts/lv_font_arial_34.c new file mode 100644 index 0000000000..e83b39fe27 --- /dev/null +++ b/src/fonts/lv_font_arial_34.c @@ -0,0 +1,5195 @@ +/******************************************************************************* + * Size: 34 px + * Bpp: 4 + * Opts: --bpp 4 --size 34 --no-compress --stride 1 --align 1 --font Arial Greek Regular.ttf --range 32-127,160-255,880-1023 --format lvgl -o lv_font_arial_34.c + ******************************************************************************/ + +#ifdef __has_include + #if __has_include("lvgl.h") + #ifndef LV_LVGL_H_INCLUDE_SIMPLE + #define LV_LVGL_H_INCLUDE_SIMPLE + #endif + #endif +#endif + +#ifdef LV_LVGL_H_INCLUDE_SIMPLE + #include "lvgl.h" +#else + #include "lvgl/lvgl.h" +#endif + + + +#ifndef LV_FONT_ARIAL_34 +#define LV_FONT_ARIAL_34 1 +#endif + +#if LV_FONT_ARIAL_34 + +/*----------------- + * BITMAPS + *----------------*/ + +/*Store the image of the glyphs*/ +static LV_ATTRIBUTE_LARGE_CONST const uint8_t glyph_bitmap[] = { + /* U+0020 " " */ + + /* U+0021 "!" */ + 0x2f, 0xff, 0x92, 0xff, 0xf9, 0x2f, 0xff, 0x92, + 0xff, 0xf9, 0x2f, 0xff, 0x91, 0xff, 0xf9, 0xf, + 0xff, 0x80, 0xff, 0xf6, 0xe, 0xff, 0x50, 0xdf, + 0xf4, 0xc, 0xff, 0x30, 0xbf, 0xf2, 0xa, 0xff, + 0x10, 0x8f, 0xf0, 0x7, 0xff, 0x0, 0x6f, 0xe0, + 0x5, 0xfd, 0x0, 0x4f, 0xc0, 0x0, 0x43, 0x0, + 0x0, 0x0, 0x6, 0x66, 0x20, 0xff, 0xf7, 0xf, + 0xff, 0x70, 0xff, 0xf7, + + /* U+0022 "\"" */ + 0x6f, 0xff, 0x0, 0xef, 0xf8, 0x6f, 0xff, 0x0, + 0xef, 0xf8, 0x6f, 0xff, 0x0, 0xef, 0xf8, 0x6f, + 0xff, 0x0, 0xef, 0xf7, 0x5f, 0xfe, 0x0, 0xdf, + 0xf6, 0x2f, 0xfb, 0x0, 0xaf, 0xf3, 0xf, 0xf9, + 0x0, 0x7f, 0xf1, 0xc, 0xf6, 0x0, 0x4f, 0xe0, + 0x6, 0x92, 0x0, 0x19, 0x70, + + /* U+0023 "#" */ + 0x0, 0x0, 0x0, 0x3f, 0xf4, 0x0, 0x0, 0x8f, + 0xf0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x0, 0x0, + 0xc, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xc0, + 0x0, 0x0, 0xff, 0x80, 0x0, 0x0, 0x0, 0xf, + 0xf8, 0x0, 0x0, 0x3f, 0xf4, 0x0, 0x0, 0x0, + 0x3, 0xff, 0x40, 0x0, 0x7, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xf1, 0x0, 0x0, 0xbf, 0xc0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x89, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf8, 0x47, 0x77, 0x8f, 0xfa, + 0x77, 0x77, 0xaf, 0xf8, 0x77, 0x40, 0x0, 0x4, + 0xff, 0x30, 0x0, 0x8, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xf0, 0x0, 0x0, 0xbf, 0xc0, 0x0, + 0x0, 0x0, 0xa, 0xfd, 0x0, 0x0, 0xf, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0x90, 0x0, 0x2, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x1f, 0xf6, 0x0, + 0x0, 0x5f, 0xf2, 0x0, 0x0, 0x47, 0x79, 0xff, + 0x97, 0x77, 0x7b, 0xff, 0x77, 0x77, 0x49, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x80, 0x0, 0xef, 0x90, 0x0, 0x2, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x1f, 0xf6, 0x0, 0x0, + 0x6f, 0xf1, 0x0, 0x0, 0x0, 0x4, 0xff, 0x30, + 0x0, 0x9, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xf0, 0x0, 0x0, 0xcf, 0xb0, 0x0, 0x0, 0x0, + 0xb, 0xfc, 0x0, 0x0, 0xf, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0xef, 0x90, 0x0, 0x3, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x1f, 0xf5, 0x0, 0x0, 0x6f, + 0xf1, 0x0, 0x0, 0x0, + + /* U+0024 "$" */ + 0x0, 0x0, 0x0, 0x7, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x36, 0xcf, 0xa6, 0x10, 0x0, + 0x0, 0x0, 0x4, 0xdf, 0xff, 0xff, 0xff, 0xa1, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe2, 0x0, 0x2, 0xff, 0xfb, 0x37, 0xf5, 0x6f, + 0xff, 0xc0, 0x0, 0xaf, 0xfa, 0x0, 0x7f, 0x40, + 0x3f, 0xff, 0x40, 0xf, 0xff, 0x10, 0x7, 0xf4, + 0x0, 0xaf, 0xf9, 0x2, 0xff, 0xd0, 0x0, 0x7f, + 0x40, 0x5, 0xc9, 0x50, 0x2f, 0xfd, 0x0, 0x7, + 0xf4, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf1, 0x0, + 0x7f, 0x40, 0x0, 0x0, 0x0, 0xd, 0xff, 0xb0, + 0x7, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xc3, 0x7f, 0x40, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xf8, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xc5, 0x0, 0x0, 0x0, + 0x0, 0x17, 0xcf, 0xff, 0xff, 0xfc, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xbe, 0xff, 0xfd, 0x10, + 0x0, 0x0, 0x0, 0x7, 0xf4, 0x6, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0x40, 0x6, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x7, 0xf4, 0x0, 0xe, + 0xff, 0x42, 0x69, 0x40, 0x0, 0x7f, 0x40, 0x0, + 0xbf, 0xf5, 0xaf, 0xf8, 0x0, 0x7, 0xf4, 0x0, + 0xb, 0xff, 0x47, 0xff, 0xd0, 0x0, 0x7f, 0x40, + 0x0, 0xef, 0xf2, 0x2f, 0xff, 0x50, 0x7, 0xf4, + 0x0, 0x6f, 0xfd, 0x0, 0xbf, 0xfe, 0x30, 0x7f, + 0x40, 0x6f, 0xff, 0x60, 0x1, 0xef, 0xff, 0xab, + 0xfa, 0xdf, 0xff, 0xa0, 0x0, 0x2, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x5a, + 0xef, 0xff, 0xea, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0x40, 0x0, 0x0, 0x0, + + /* U+0025 "%" */ + 0x0, 0x5c, 0xff, 0xd8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xb0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x4f, 0xf2, + 0x0, 0x0, 0x0, 0x4f, 0xfc, 0x31, 0x6f, 0xfb, + 0x0, 0x0, 0x0, 0xd, 0xf9, 0x0, 0x0, 0x0, + 0xa, 0xff, 0x10, 0x0, 0x8f, 0xf2, 0x0, 0x0, + 0x6, 0xff, 0x10, 0x0, 0x0, 0x0, 0xef, 0xc0, + 0x0, 0x4, 0xff, 0x50, 0x0, 0x0, 0xef, 0x80, + 0x0, 0x0, 0x0, 0xe, 0xfa, 0x0, 0x0, 0x2f, + 0xf6, 0x0, 0x0, 0x7f, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xb0, 0x0, 0x4, 0xff, 0x50, 0x0, + 0x1f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0x0, 0x0, 0x8f, 0xf2, 0x0, 0x9, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xfa, 0x20, 0x5f, + 0xfc, 0x0, 0x2, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xfe, 0x20, 0x0, + 0xbf, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5c, 0xff, 0xe8, 0x10, 0x0, 0x4f, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xfa, 0x0, 0x5, 0xcf, 0xfc, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0x10, 0x9, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0x80, 0x4, + 0xff, 0xa2, 0x2a, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xe0, 0x0, 0xbf, 0xe0, 0x0, + 0xd, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xf6, 0x0, 0xf, 0xf9, 0x0, 0x0, 0x9f, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xfd, 0x0, 0x2, + 0xff, 0x70, 0x0, 0x7, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x2, 0xff, 0x50, 0x0, 0x3f, 0xf6, 0x0, + 0x0, 0x6f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xc0, 0x0, 0x2, 0xff, 0x60, 0x0, 0x7, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x4f, 0xf3, 0x0, 0x0, + 0xf, 0xf8, 0x0, 0x0, 0x9f, 0xf0, 0x0, 0x0, + 0x0, 0xc, 0xfa, 0x0, 0x0, 0x0, 0xbf, 0xd0, + 0x0, 0xe, 0xfb, 0x0, 0x0, 0x0, 0x5, 0xff, + 0x20, 0x0, 0x0, 0x4, 0xff, 0x91, 0x2a, 0xff, + 0x30, 0x0, 0x0, 0x0, 0xef, 0x80, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x7f, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xcf, 0xfb, 0x40, 0x0, + + /* U+0026 "&" */ + 0x0, 0x0, 0x0, 0x4b, 0xef, 0xeb, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xa8, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0x30, 0x0, 0x7f, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xb0, 0x0, 0x0, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfa, + 0x0, 0x0, 0xe, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xe0, 0x0, 0x2, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xa0, 0x0, 0xcf, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0x72, 0xcf, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xe2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2c, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xe5, 0xdf, 0xff, 0x30, 0x0, 0x30, 0x0, + 0x0, 0x3f, 0xff, 0xb1, 0x2, 0xef, 0xfe, 0x10, + 0x1f, 0xfd, 0x10, 0xd, 0xff, 0xb0, 0x0, 0x3, + 0xff, 0xfc, 0x6, 0xff, 0xe0, 0x4, 0xff, 0xf1, + 0x0, 0x0, 0x5, 0xff, 0xfa, 0xdf, 0xf8, 0x0, + 0x7f, 0xfb, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0x10, 0x7, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0x80, 0x0, 0x5f, 0xff, 0x10, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xf6, 0x0, 0x1, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xf4, 0x0, 0x8, 0xff, 0xf9, 0x0, 0x0, 0x3c, + 0xff, 0xfe, 0xff, 0xf5, 0x0, 0xc, 0xff, 0xfe, + 0xba, 0xdf, 0xff, 0xf5, 0x3f, 0xff, 0xf7, 0x0, + 0xa, 0xff, 0xff, 0xff, 0xff, 0xd3, 0x0, 0x3e, + 0xff, 0x40, 0x0, 0x3, 0x9d, 0xff, 0xda, 0x50, + 0x0, 0x0, 0x2d, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0027 "'" */ + 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, + 0x6f, 0xfd, 0x3f, 0xfb, 0xf, 0xf8, 0xe, 0xf5, + 0x7, 0x92, + + /* U+0028 "(" */ + 0x0, 0x0, 0x6, 0xfc, 0x0, 0x0, 0x2, 0xff, + 0x30, 0x0, 0x0, 0xcf, 0xa0, 0x0, 0x0, 0x6f, + 0xf2, 0x0, 0x0, 0xe, 0xfa, 0x0, 0x0, 0x8, + 0xff, 0x30, 0x0, 0x0, 0xef, 0xd0, 0x0, 0x0, + 0x6f, 0xf7, 0x0, 0x0, 0xb, 0xff, 0x20, 0x0, + 0x1, 0xff, 0xd0, 0x0, 0x0, 0x5f, 0xfa, 0x0, + 0x0, 0x8, 0xff, 0x70, 0x0, 0x0, 0xbf, 0xf5, + 0x0, 0x0, 0xd, 0xff, 0x30, 0x0, 0x0, 0xef, + 0xf2, 0x0, 0x0, 0xe, 0xff, 0x20, 0x0, 0x0, + 0xef, 0xf2, 0x0, 0x0, 0xd, 0xff, 0x30, 0x0, + 0x0, 0xbf, 0xf5, 0x0, 0x0, 0x8, 0xff, 0x70, + 0x0, 0x0, 0x5f, 0xfa, 0x0, 0x0, 0x1, 0xff, + 0xe0, 0x0, 0x0, 0xc, 0xff, 0x20, 0x0, 0x0, + 0x6f, 0xf7, 0x0, 0x0, 0x0, 0xef, 0xd0, 0x0, + 0x0, 0x8, 0xff, 0x30, 0x0, 0x0, 0x1e, 0xfa, + 0x0, 0x0, 0x0, 0x7f, 0xf2, 0x0, 0x0, 0x0, + 0xcf, 0xa0, 0x0, 0x0, 0x2, 0xff, 0x30, 0x0, + 0x0, 0x6, 0xfc, 0x0, + + /* U+0029 ")" */ + 0x7f, 0xb0, 0x0, 0x0, 0x0, 0xdf, 0x70, 0x0, + 0x0, 0x5, 0xff, 0x20, 0x0, 0x0, 0xc, 0xfb, + 0x0, 0x0, 0x0, 0x5f, 0xf4, 0x0, 0x0, 0x0, + 0xdf, 0xd0, 0x0, 0x0, 0x8, 0xff, 0x40, 0x0, + 0x0, 0x2f, 0xfb, 0x0, 0x0, 0x0, 0xdf, 0xf1, + 0x0, 0x0, 0x9, 0xff, 0x60, 0x0, 0x0, 0x5f, + 0xfa, 0x0, 0x0, 0x2, 0xff, 0xd0, 0x0, 0x0, + 0xf, 0xff, 0x0, 0x0, 0x0, 0xef, 0xf2, 0x0, + 0x0, 0xd, 0xff, 0x30, 0x0, 0x0, 0xdf, 0xf4, + 0x0, 0x0, 0xd, 0xff, 0x30, 0x0, 0x0, 0xef, + 0xf2, 0x0, 0x0, 0xf, 0xff, 0x0, 0x0, 0x2, + 0xff, 0xe0, 0x0, 0x0, 0x5f, 0xfa, 0x0, 0x0, + 0x9, 0xff, 0x60, 0x0, 0x0, 0xdf, 0xf1, 0x0, + 0x0, 0x2f, 0xfb, 0x0, 0x0, 0x8, 0xff, 0x40, + 0x0, 0x0, 0xef, 0xc0, 0x0, 0x0, 0x5f, 0xf4, + 0x0, 0x0, 0xc, 0xfb, 0x0, 0x0, 0x5, 0xff, + 0x20, 0x0, 0x0, 0xdf, 0x70, 0x0, 0x0, 0x7f, + 0xb0, 0x0, 0x0, 0x0, + + /* U+002A "*" */ + 0x0, 0x0, 0x9f, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xb0, 0x0, 0x0, 0x14, 0x0, 0x7f, 0x90, + 0x2, 0x20, 0x6f, 0xe7, 0x6f, 0x86, 0xcf, 0xa0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x3, 0x6a, + 0xff, 0xfb, 0x84, 0x0, 0x0, 0x7, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x5f, 0xf3, 0xef, 0x90, 0x0, + 0x3, 0xff, 0x90, 0x6f, 0xf7, 0x0, 0x1, 0xae, + 0x10, 0xb, 0xd2, 0x0, 0x0, 0x1, 0x0, 0x1, + 0x0, 0x0, + + /* U+002B "+" */ + 0x0, 0x0, 0x0, 0x0, 0x11, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0x50, 0x0, 0x0, 0x1, 0xcc, 0xcc, 0xcc, 0xef, + 0xfd, 0xcc, 0xcc, 0xcc, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf1, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x7, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0x50, 0x0, 0x0, + 0x0, + + /* U+002C "," */ + 0x6, 0x66, 0x20, 0xff, 0xf5, 0xf, 0xff, 0x50, + 0xff, 0xf5, 0x0, 0x6f, 0x40, 0x9, 0xf2, 0x1, + 0xed, 0x1, 0xef, 0x40, 0x7, 0x30, 0x0, + + /* U+002D "-" */ + 0xef, 0xff, 0xff, 0xff, 0xf4, 0xef, 0xff, 0xff, + 0xff, 0xf4, 0xef, 0xff, 0xff, 0xff, 0xf4, + + /* U+002E "." */ + 0x66, 0x62, 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, + + /* U+002F "/" */ + 0x0, 0x0, 0x0, 0x1f, 0xf4, 0x0, 0x0, 0x0, + 0x6f, 0xf0, 0x0, 0x0, 0x0, 0xaf, 0xb0, 0x0, + 0x0, 0x0, 0xff, 0x60, 0x0, 0x0, 0x4, 0xff, + 0x20, 0x0, 0x0, 0x8, 0xfd, 0x0, 0x0, 0x0, + 0xd, 0xf8, 0x0, 0x0, 0x0, 0x2f, 0xf3, 0x0, + 0x0, 0x0, 0x7f, 0xf0, 0x0, 0x0, 0x0, 0xbf, + 0xa0, 0x0, 0x0, 0x0, 0xff, 0x50, 0x0, 0x0, + 0x5, 0xff, 0x10, 0x0, 0x0, 0x9, 0xfc, 0x0, + 0x0, 0x0, 0xe, 0xf7, 0x0, 0x0, 0x0, 0x3f, + 0xf3, 0x0, 0x0, 0x0, 0x8f, 0xe0, 0x0, 0x0, + 0x0, 0xcf, 0x90, 0x0, 0x0, 0x1, 0xff, 0x50, + 0x0, 0x0, 0x6, 0xff, 0x0, 0x0, 0x0, 0xa, + 0xfb, 0x0, 0x0, 0x0, 0xf, 0xf6, 0x0, 0x0, + 0x0, 0x4f, 0xf2, 0x0, 0x0, 0x0, 0x8f, 0xd0, + 0x0, 0x0, 0x0, 0xdf, 0x80, 0x0, 0x0, 0x0, + + /* U+0030 "0" */ + 0x0, 0x0, 0x7, 0xce, 0xfe, 0xb6, 0x0, 0x0, + 0x0, 0x0, 0x3e, 0xff, 0xff, 0xff, 0xfc, 0x20, + 0x0, 0x0, 0x2f, 0xff, 0xe9, 0x8a, 0xff, 0xfd, + 0x10, 0x0, 0xc, 0xff, 0xb0, 0x0, 0x1, 0xdf, + 0xf9, 0x0, 0x4, 0xff, 0xd0, 0x0, 0x0, 0x1, + 0xff, 0xf2, 0x0, 0xaf, 0xf6, 0x0, 0x0, 0x0, + 0x9, 0xff, 0x70, 0xe, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x4f, 0xfc, 0x2, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf0, 0x4f, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0x16, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf3, 0x7f, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0x47, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf5, 0x7f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0x57, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf4, 0x6f, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0x34, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf1, + 0x2f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0x0, 0xef, 0xf1, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xc0, 0xa, 0xff, 0x60, 0x0, 0x0, 0x0, 0x9f, + 0xf7, 0x0, 0x4f, 0xfd, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x20, 0x0, 0xcf, 0xfb, 0x0, 0x0, 0x1c, + 0xff, 0x90, 0x0, 0x2, 0xff, 0xfe, 0x97, 0x9f, + 0xff, 0xd1, 0x0, 0x0, 0x3, 0xef, 0xff, 0xff, + 0xff, 0xc2, 0x0, 0x0, 0x0, 0x0, 0x7c, 0xef, + 0xeb, 0x60, 0x0, 0x0, + + /* U+0031 "1" */ + 0x0, 0x0, 0x0, 0x8, 0xfb, 0x0, 0x0, 0x0, + 0x3f, 0xfb, 0x0, 0x0, 0x2, 0xef, 0xfb, 0x0, + 0x0, 0x4e, 0xff, 0xfb, 0x0, 0x8, 0xff, 0xff, + 0xfb, 0x6, 0xef, 0xff, 0xbf, 0xfb, 0x3f, 0xff, + 0xe5, 0x4f, 0xfb, 0x3f, 0xf9, 0x10, 0x4f, 0xfb, + 0x28, 0x10, 0x0, 0x4f, 0xfb, 0x0, 0x0, 0x0, + 0x4f, 0xfb, 0x0, 0x0, 0x0, 0x4f, 0xfb, 0x0, + 0x0, 0x0, 0x4f, 0xfb, 0x0, 0x0, 0x0, 0x4f, + 0xfb, 0x0, 0x0, 0x0, 0x4f, 0xfb, 0x0, 0x0, + 0x0, 0x4f, 0xfb, 0x0, 0x0, 0x0, 0x4f, 0xfb, + 0x0, 0x0, 0x0, 0x4f, 0xfb, 0x0, 0x0, 0x0, + 0x4f, 0xfb, 0x0, 0x0, 0x0, 0x4f, 0xfb, 0x0, + 0x0, 0x0, 0x4f, 0xfb, 0x0, 0x0, 0x0, 0x4f, + 0xfb, 0x0, 0x0, 0x0, 0x4f, 0xfb, 0x0, 0x0, + 0x0, 0x4f, 0xfb, 0x0, 0x0, 0x0, 0x4f, 0xfb, + + /* U+0032 "2" */ + 0x0, 0x0, 0x28, 0xce, 0xfe, 0xc8, 0x20, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0xaf, 0xff, 0xd9, 0x79, 0xdf, 0xff, + 0x90, 0x0, 0x6f, 0xff, 0x50, 0x0, 0x0, 0x7f, + 0xff, 0x40, 0xd, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x8f, 0xfb, 0x2, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xf0, 0x4f, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0x10, 0x2, 0x20, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1c, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3e, 0xff, 0xe3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xd2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xfe, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xd2, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x2e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf2, + + /* U+0033 "3" */ + 0x0, 0x0, 0x29, 0xdf, 0xfe, 0xa4, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xfc, 0x10, + 0x0, 0x0, 0x9f, 0xff, 0xb8, 0x8a, 0xff, 0xfd, + 0x10, 0x0, 0x4f, 0xff, 0x40, 0x0, 0x2, 0xdf, + 0xf9, 0x0, 0xc, 0xff, 0x70, 0x0, 0x0, 0x2, + 0xff, 0xf0, 0x1, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0x20, 0x2, 0x46, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2d, 0xff, 0x80, 0x0, 0x0, 0x0, 0x1, + 0x57, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xc2, 0x0, 0x0, 0x0, + 0x0, 0x21, 0x1, 0x6e, 0xff, 0xe2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0x65, 0xdf, 0xa0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xf5, 0x4f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0x20, 0xef, 0xf7, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xc0, 0x6, 0xff, 0xf5, 0x0, 0x0, 0xa, + 0xff, 0xf3, 0x0, 0xa, 0xff, 0xfc, 0x87, 0xae, + 0xff, 0xf6, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xe4, 0x0, 0x0, 0x0, 0x2, 0x9d, 0xff, + 0xeb, 0x60, 0x0, 0x0, + + /* U+0034 "4" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0x7f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xfb, 0xf, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xe1, 0xf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0x40, 0xf, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xf9, 0x0, 0xf, 0xff, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xd0, 0x0, 0xf, + 0xff, 0x0, 0x0, 0x0, 0xb, 0xff, 0x20, 0x0, + 0xf, 0xff, 0x0, 0x0, 0x0, 0x7f, 0xf6, 0x0, + 0x0, 0xf, 0xff, 0x0, 0x0, 0x3, 0xff, 0xb0, + 0x0, 0x0, 0xf, 0xff, 0x0, 0x0, 0x1e, 0xfe, + 0x10, 0x0, 0x0, 0xf, 0xff, 0x0, 0x0, 0x7f, + 0xfe, 0xbb, 0xbb, 0xbb, 0xbf, 0xff, 0xbb, 0xb3, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf5, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x0, 0x0, + + /* U+0035 "5" */ + 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x2f, 0xff, 0xdd, 0xdd, 0xdd, 0xdd, + 0xd6, 0x0, 0x5, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xfc, 0x2, 0x79, + 0x97, 0x30, 0x0, 0x0, 0x4, 0xff, 0xbb, 0xff, + 0xff, 0xff, 0xc2, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0xb, 0xff, 0xfb, + 0x41, 0x2, 0x7e, 0xff, 0xf3, 0x0, 0xef, 0xf8, + 0x0, 0x0, 0x0, 0x2e, 0xff, 0xc0, 0x1, 0x34, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0x86, 0xef, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xf5, 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0x10, 0xef, 0xf8, 0x0, 0x0, 0x0, 0xc, + 0xff, 0x90, 0x7, 0xff, 0xf6, 0x0, 0x0, 0xa, + 0xff, 0xe1, 0x0, 0xb, 0xff, 0xfd, 0x87, 0x9e, + 0xff, 0xf4, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xe4, 0x0, 0x0, 0x0, 0x2, 0x8d, 0xff, + 0xeb, 0x60, 0x0, 0x0, + + /* U+0036 "6" */ + 0x0, 0x0, 0x3, 0x9d, 0xff, 0xea, 0x40, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0xb, 0xff, 0xfb, 0x88, 0xbf, 0xff, + 0xc0, 0x0, 0x8, 0xff, 0xd2, 0x0, 0x0, 0x4f, + 0xff, 0x60, 0x2, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x7f, 0xfc, 0x0, 0x8f, 0xf7, 0x0, 0x0, 0x0, + 0x1, 0xdc, 0xb0, 0xd, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf9, 0x0, 0x6c, + 0xef, 0xea, 0x30, 0x0, 0x6, 0xff, 0x72, 0xdf, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x7f, 0xf8, 0xef, + 0xfc, 0xab, 0xff, 0xff, 0xa0, 0x8, 0xff, 0xff, + 0xd2, 0x0, 0x0, 0x9f, 0xff, 0x50, 0x9f, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x9f, 0xfd, 0x8, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf2, 0x7f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0x66, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf7, + 0x4f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0x61, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xf5, 0xc, 0xff, 0x60, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x10, 0x6f, 0xfe, 0x10, 0x0, 0x0, 0x8, + 0xff, 0xb0, 0x0, 0xcf, 0xfc, 0x10, 0x0, 0x6, + 0xff, 0xf3, 0x0, 0x2, 0xef, 0xff, 0xa7, 0x8c, + 0xff, 0xf7, 0x0, 0x0, 0x1, 0xcf, 0xff, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x4a, 0xdf, + 0xfd, 0x92, 0x0, 0x0, + + /* U+0037 "7" */ + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x75, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf7, 0x4e, 0xee, 0xee, 0xee, 0xee, 0xee, 0xef, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, + + /* U+0038 "8" */ + 0x0, 0x0, 0x18, 0xce, 0xfe, 0xc7, 0x10, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xfe, 0x50, + 0x0, 0x0, 0x5f, 0xff, 0xe9, 0x79, 0xef, 0xff, + 0x50, 0x0, 0xe, 0xff, 0x80, 0x0, 0x1, 0xaf, + 0xfe, 0x0, 0x5, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0xdf, 0xf5, 0x0, 0x8f, 0xf8, 0x0, 0x0, 0x0, + 0x9, 0xff, 0x70, 0x8, 0xff, 0x90, 0x0, 0x0, + 0x0, 0xbf, 0xf5, 0x0, 0x5f, 0xff, 0x20, 0x0, + 0x0, 0x3f, 0xff, 0x10, 0x0, 0xef, 0xfe, 0x72, + 0x2, 0x7f, 0xff, 0x70, 0x0, 0x3, 0xef, 0xff, + 0xff, 0xff, 0xfd, 0x50, 0x0, 0x0, 0x1, 0x9f, + 0xff, 0xff, 0xff, 0xa2, 0x0, 0x0, 0x1, 0x9f, + 0xfc, 0x87, 0x9e, 0xff, 0xf6, 0x0, 0x1, 0xdf, + 0xf5, 0x0, 0x0, 0x8, 0xff, 0xf4, 0x0, 0xbf, + 0xf6, 0x0, 0x0, 0x0, 0x8, 0xff, 0xd0, 0x2f, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0x36, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf6, + 0x8f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0x78, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xf6, 0x5f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0x31, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xe0, 0x8, 0xff, 0xf7, 0x0, 0x0, 0x7, + 0xff, 0xf5, 0x0, 0xb, 0xff, 0xfd, 0x87, 0x8d, + 0xff, 0xf9, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x2, 0x8c, 0xef, + 0xec, 0x71, 0x0, 0x0, + + /* U+0039 "9" */ + 0x0, 0x0, 0x29, 0xdf, 0xfd, 0x94, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xfb, 0x10, + 0x0, 0x0, 0x9f, 0xff, 0xe9, 0x79, 0xef, 0xfd, + 0x10, 0x0, 0x5f, 0xff, 0x90, 0x0, 0x0, 0xaf, + 0xfb, 0x0, 0xd, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0xcf, 0xf4, 0x2, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xa0, 0x6f, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0x7, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf2, 0x7f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0x56, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xf6, 0x2f, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0x60, 0xcf, 0xfc, + 0x10, 0x0, 0x0, 0x2f, 0xff, 0xf7, 0x3, 0xff, + 0xfd, 0x61, 0x1, 0x7e, 0xfe, 0xff, 0x60, 0x6, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0x8f, 0xf6, 0x0, + 0x4, 0xdf, 0xff, 0xff, 0xe6, 0x9, 0xff, 0x50, + 0x0, 0x0, 0x48, 0x98, 0x50, 0x0, 0xbf, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xc0, 0xe, 0xff, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xf6, 0x0, 0xcf, 0xf5, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x10, 0x6, 0xff, 0xe2, 0x0, 0x0, 0x3e, + 0xff, 0x60, 0x0, 0xc, 0xff, 0xfa, 0x88, 0xbf, + 0xff, 0xa0, 0x0, 0x0, 0x1b, 0xff, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x5, 0xae, 0xfe, + 0xd8, 0x20, 0x0, 0x0, + + /* U+003A ":" */ + 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, 0x66, 0x62, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x66, 0x62, 0xff, 0xf6, + 0xff, 0xf6, 0xff, 0xf6, + + /* U+003B ";" */ + 0xf, 0xff, 0x50, 0xff, 0xf5, 0xf, 0xff, 0x50, + 0x66, 0x62, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0x66, 0x20, 0xff, 0xf5, + 0xf, 0xff, 0x50, 0xff, 0xf5, 0x0, 0x6f, 0x40, + 0x9, 0xf2, 0x1, 0xed, 0x1, 0xef, 0x40, 0x7, + 0x30, 0x0, + + /* U+003C "<" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x9f, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4b, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x17, 0xdf, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x3, 0x9f, 0xff, + 0xff, 0xc6, 0x0, 0x0, 0x0, 0x5c, 0xff, 0xff, + 0xf9, 0x30, 0x0, 0x0, 0x18, 0xef, 0xff, 0xfd, + 0x60, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xa3, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xe7, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfd, 0x71, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xfa, 0x30, 0x0, 0x0, 0x0, 0x0, 0x1, 0x7e, + 0xff, 0xff, 0xd6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xcf, 0xff, 0xff, 0x92, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3a, 0xff, 0xff, 0xfc, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x7e, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xcf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x29, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, + + /* U+003D "=" */ + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x1c, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, + 0xcc, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xcc, 0xcc, 0xcc, 0xcc, + 0xcc, 0xcc, 0xcc, 0xcc, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf1, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, + + /* U+003E ">" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xe8, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xa4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xfd, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x6d, 0xff, 0xff, 0xf9, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xaf, 0xff, 0xff, + 0xb4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x17, 0xef, + 0xff, 0xfd, 0x71, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4b, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0x8e, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x18, 0xef, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xbf, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x1, 0x7d, 0xff, 0xff, 0xd7, 0x0, 0x0, 0x0, + 0x3a, 0xff, 0xff, 0xfb, 0x40, 0x0, 0x0, 0x6, + 0xcf, 0xff, 0xff, 0x92, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xd6, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xfb, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0x82, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+003F "?" */ + 0x0, 0x0, 0x28, 0xce, 0xfe, 0xc8, 0x20, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0xaf, 0xff, 0xd8, 0x79, 0xdf, 0xff, + 0xb0, 0x0, 0x6f, 0xff, 0x60, 0x0, 0x0, 0x7f, + 0xff, 0x70, 0xd, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x8f, 0xfe, 0x2, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf2, 0x5f, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0x30, 0x1, 0x10, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x11, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x16, 0x66, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xf2, 0x0, 0x0, 0x0, + + /* U+0040 "@" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x6a, 0xce, + 0xff, 0xed, 0xb8, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5c, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xcf, 0xff, 0xfe, + 0xa9, 0x77, 0x89, 0xcf, 0xff, 0xfe, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x83, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xdf, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf9, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, + 0xff, 0x40, 0x0, 0x0, 0x1, 0xef, 0xf4, 0x0, + 0x0, 0x17, 0xcf, 0xeb, 0x40, 0xa, 0xff, 0x50, + 0x2e, 0xfd, 0x0, 0x0, 0x0, 0x9f, 0xf6, 0x0, + 0x0, 0x4e, 0xff, 0xff, 0xff, 0x90, 0xdf, 0xf1, + 0x0, 0x5f, 0xf7, 0x0, 0x0, 0x2f, 0xf9, 0x0, + 0x0, 0x5f, 0xff, 0xd8, 0x8c, 0xff, 0x7f, 0xfe, + 0x0, 0x0, 0xcf, 0xd0, 0x0, 0xa, 0xff, 0x10, + 0x0, 0x3f, 0xff, 0x70, 0x0, 0x6, 0xff, 0xff, + 0xb0, 0x0, 0x6, 0xff, 0x20, 0x1, 0xff, 0x80, + 0x0, 0xd, 0xff, 0x70, 0x0, 0x0, 0xb, 0xff, + 0xf7, 0x0, 0x0, 0x1f, 0xf5, 0x0, 0x5f, 0xf2, + 0x0, 0x7, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x40, 0x0, 0x0, 0xff, 0x70, 0xa, 0xfe, + 0x0, 0x0, 0xef, 0xf4, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xf1, 0x0, 0x0, 0xe, 0xf8, 0x0, 0xdf, + 0xa0, 0x0, 0x4f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xfd, 0x0, 0x0, 0x0, 0xff, 0x70, 0xf, + 0xf8, 0x0, 0x8, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xa0, 0x0, 0x0, 0x2f, 0xf5, 0x0, + 0xff, 0x70, 0x0, 0xaf, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xf7, 0x0, 0x0, 0x6, 0xff, 0x20, + 0x1f, 0xf6, 0x0, 0xb, 0xff, 0x50, 0x0, 0x0, + 0x0, 0xa, 0xff, 0x30, 0x0, 0x0, 0xdf, 0xd0, + 0x0, 0xff, 0x70, 0x0, 0xbf, 0xf5, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xf0, 0x0, 0x0, 0x6f, 0xf6, + 0x0, 0xf, 0xf9, 0x0, 0x8, 0xff, 0x80, 0x0, + 0x0, 0x0, 0xaf, 0xfd, 0x0, 0x0, 0x2e, 0xfd, + 0x0, 0x0, 0xdf, 0xc0, 0x0, 0x4f, 0xfe, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xa0, 0x0, 0x2d, 0xff, + 0x30, 0x0, 0x9, 0xff, 0x10, 0x0, 0xef, 0xf9, + 0x0, 0x0, 0x6f, 0xff, 0xfa, 0x0, 0x6e, 0xff, + 0x60, 0x0, 0x0, 0x4f, 0xf6, 0x0, 0x4, 0xff, + 0xfd, 0x88, 0xdf, 0xeb, 0xff, 0xfd, 0xef, 0xff, + 0x60, 0x0, 0x0, 0x0, 0xef, 0xd0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xd2, 0x5f, 0xff, 0xff, 0xfd, + 0x30, 0x0, 0x0, 0x0, 0x7, 0xff, 0x80, 0x0, + 0x3, 0xae, 0xfd, 0x70, 0x0, 0x7d, 0xfe, 0xb5, + 0x0, 0x0, 0x45, 0x51, 0x0, 0xd, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xfd, 0x0, 0x0, 0x2f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xfe, 0x20, 0x0, 0x0, 0x4f, + 0xff, 0xb2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xbf, 0xfe, 0x30, 0x0, 0x0, 0x0, + 0x3d, 0xff, 0xfb, 0x61, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4b, 0xff, 0xfd, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xfe, 0xb9, 0x87, 0x78, + 0xac, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x91, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0x7a, 0xcd, 0xef, + 0xfe, 0xda, 0x84, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0041 "A" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xfb, 0xbf, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf7, 0x5f, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xf2, 0xf, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xd0, 0xa, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0x70, 0x4, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x10, 0x0, 0xdf, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xfb, 0x0, 0x0, 0x7f, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xf5, 0x0, 0x0, 0x1f, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xe0, 0x0, 0x0, 0xb, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0x90, 0x0, 0x0, 0x5, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0x30, 0x0, 0x0, 0x0, 0xef, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x1, 0xff, 0xfa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xae, 0xff, 0xa0, 0x0, 0x0, 0x7, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf1, 0x0, + 0x0, 0xd, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xf7, 0x0, 0x0, 0x4f, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfe, 0x0, + 0x0, 0xaf, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x40, 0x1, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xb0, + 0x6, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf2, 0xd, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf8, + + /* U+0042 "B" */ + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xb6, 0x10, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x8f, 0xff, 0xee, 0xee, 0xee, + 0xff, 0xff, 0xff, 0x60, 0x8, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x15, 0xdf, 0xff, 0x10, 0x8f, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xf7, 0x8, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xa0, 0x8f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfa, 0x8, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0x70, 0x8f, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xf2, 0x8, 0xff, 0xb0, + 0x0, 0x0, 0x1, 0x37, 0xef, 0xf7, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x50, 0x0, 0x8f, 0xff, 0xee, 0xee, 0xee, 0xef, + 0xff, 0xff, 0xb0, 0x8, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x3, 0x9f, 0xff, 0xc0, 0x8f, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x58, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfb, + 0x8f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xd8, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xfd, 0x8f, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xb8, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf7, 0x8f, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x28, 0xff, 0xfe, 0x18, + 0xff, 0xfd, 0xdd, 0xdd, 0xde, 0xff, 0xff, 0xff, + 0x40, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x40, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xec, 0x95, 0x0, 0x0, + + /* U+0043 "C" */ + 0x0, 0x0, 0x0, 0x2, 0x7b, 0xdf, 0xfe, 0xc8, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2a, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb2, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xed, 0xcd, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf7, 0x20, + 0x0, 0x1, 0x7f, 0xff, 0xf2, 0x0, 0x0, 0x3f, + 0xff, 0xc1, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xc0, 0x0, 0xc, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x50, 0x4, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfa, + 0x0, 0x9f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0x52, 0x0, 0xd, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x84, 0x0, + 0x8, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x10, 0x2f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xd0, 0x0, + 0xbf, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf6, 0x0, 0x2, 0xff, 0xfc, 0x10, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xfd, 0x0, 0x0, 0x6, + 0xff, 0xff, 0x71, 0x0, 0x0, 0x29, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x7, 0xff, 0xff, 0xfe, 0xcc, + 0xef, 0xff, 0xfe, 0x30, 0x0, 0x0, 0x0, 0x3, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x38, 0xcd, 0xff, 0xec, + 0x82, 0x0, 0x0, 0x0, + + /* U+0044 "D" */ + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xc9, 0x50, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe4, 0x0, 0x0, 0x5f, 0xff, 0xee, + 0xee, 0xee, 0xef, 0xff, 0xff, 0xf6, 0x0, 0x5, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x3, 0x8f, 0xff, + 0xf4, 0x0, 0x5f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2e, 0xff, 0xe0, 0x5, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x70, 0x5f, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xfe, 0x5, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xf3, 0x5f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0x75, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xf9, 0x5f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xb5, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfc, 0x5f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xc5, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xfb, 0x5f, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0x95, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf7, + 0x5f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x35, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xe0, 0x5f, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf7, 0x5, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, + 0xfe, 0x0, 0x5f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x38, 0xff, 0xff, 0x40, 0x5, 0xff, 0xfd, 0xdd, + 0xdd, 0xde, 0xff, 0xff, 0xff, 0x50, 0x0, 0x5f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x30, + 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xdb, + 0x72, 0x0, 0x0, 0x0, + + /* U+0045 "E" */ + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x45, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf4, 0x5f, 0xff, 0xee, 0xee, 0xee, + 0xee, 0xee, 0xee, 0xee, 0x35, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, + 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x60, 0x5f, 0xff, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xd5, 0x5, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xfd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdb, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd5, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, + + /* U+0046 "F" */ + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf2, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf2, 0x4f, 0xff, 0xee, 0xee, 0xee, 0xee, + 0xee, 0xee, 0xe1, 0x4f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xee, 0xee, 0xee, 0xee, + 0xee, 0xe5, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x4f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf5, 0x0, 0x4f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0047 "G" */ + 0x0, 0x0, 0x0, 0x1, 0x59, 0xce, 0xff, 0xec, + 0x94, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd4, 0x0, 0x0, + 0x0, 0x0, 0x2d, 0xff, 0xff, 0xfd, 0xcc, 0xdf, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x2, 0xef, 0xff, + 0xa4, 0x0, 0x0, 0x0, 0x5d, 0xff, 0xf6, 0x0, + 0x0, 0xd, 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0x10, 0x0, 0x9f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0x70, + 0x1, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0x90, 0x7, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x30, 0x0, + 0xc, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x10, 0x0, + 0x0, 0x0, 0xd, 0xdd, 0xdd, 0xdd, 0xdd, 0xd3, + 0x3f, 0xff, 0x10, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x1f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0xf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xf4, 0xc, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf4, + 0x8, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xf4, 0x2, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf4, + 0x0, 0x9f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xf4, 0x0, 0xd, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6e, 0xff, 0xf4, + 0x0, 0x2, 0xef, 0xff, 0xe7, 0x30, 0x0, 0x3, + 0x8e, 0xff, 0xff, 0xb1, 0x0, 0x0, 0x1c, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x6e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x48, 0xce, 0xff, 0xec, 0x94, 0x0, 0x0, 0x0, + + /* U+0048 "H" */ + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfd, 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfd, 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfd, 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x4f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x4f, 0xff, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xef, 0xfd, 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfd, 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfd, 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, + + /* U+0049 "I" */ + 0xef, 0xf5, 0xef, 0xf5, 0xef, 0xf5, 0xef, 0xf5, + 0xef, 0xf5, 0xef, 0xf5, 0xef, 0xf5, 0xef, 0xf5, + 0xef, 0xf5, 0xef, 0xf5, 0xef, 0xf5, 0xef, 0xf5, + 0xef, 0xf5, 0xef, 0xf5, 0xef, 0xf5, 0xef, 0xf5, + 0xef, 0xf5, 0xef, 0xf5, 0xef, 0xf5, 0xef, 0xf5, + 0xef, 0xf5, 0xef, 0xf5, 0xef, 0xf5, 0xef, 0xf5, + + /* U+004A "J" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x3, 0x57, 0x0, 0x0, 0x0, 0xd, 0xff, 0x50, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0xef, 0xf4, 0xe, + 0xff, 0x20, 0x0, 0x0, 0x1f, 0xff, 0x20, 0xbf, + 0xf9, 0x0, 0x0, 0x6, 0xff, 0xf0, 0x6, 0xff, + 0xf7, 0x0, 0x5, 0xff, 0xfa, 0x0, 0xd, 0xff, + 0xff, 0xef, 0xff, 0xff, 0x20, 0x0, 0x2d, 0xff, + 0xff, 0xff, 0xfe, 0x30, 0x0, 0x0, 0x7, 0xce, + 0xfe, 0xc7, 0x0, 0x0, + + /* U+004B "K" */ + 0x8f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfa, 0x8, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf9, 0x0, 0x8f, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xf8, 0x0, 0x8, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf8, + 0x0, 0x0, 0x8f, 0xfb, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xf7, 0x0, 0x0, 0x8, 0xff, 0xb0, 0x0, + 0x0, 0xb, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x8f, + 0xfb, 0x0, 0x0, 0xb, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xb0, 0x0, 0xc, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfb, 0x0, 0xc, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xb0, 0xc, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xfb, 0xc, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xcc, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xe2, 0xcf, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xe2, 0x2, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xd1, 0x0, 0x6, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x8, 0xff, 0xe1, + 0x0, 0x0, 0xa, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x8f, 0xfb, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xe1, + 0x0, 0x0, 0x8, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xc0, 0x0, 0x0, 0x8f, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0x80, 0x0, 0x8, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x40, 0x0, 0x8f, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xfe, 0x10, 0x8, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xfb, 0x0, 0x8f, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf8, 0x8, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xf4, + + /* U+004C "L" */ + 0x7f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xda, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + + /* U+004D "M" */ + 0x7f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xfc, 0x7f, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfc, + 0x7f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xfc, 0x7f, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfc, + 0x7f, 0xfb, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xcf, 0xfc, 0x7f, 0xfa, 0xaf, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x7f, 0xfc, + 0x7f, 0xfa, 0x5f, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xfc, 0x5f, 0xfc, 0x7f, 0xfa, 0xf, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xf6, 0x5f, 0xfc, + 0x7f, 0xfa, 0xa, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x8f, 0xf1, 0x5f, 0xfc, 0x7f, 0xfa, 0x4, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0xdf, 0xb0, 0x5f, 0xfc, + 0x7f, 0xfa, 0x0, 0xef, 0xf0, 0x0, 0x0, 0x3, + 0xff, 0x50, 0x5f, 0xfc, 0x7f, 0xfa, 0x0, 0x9f, + 0xf4, 0x0, 0x0, 0x8, 0xff, 0x0, 0x5f, 0xfc, + 0x7f, 0xfa, 0x0, 0x4f, 0xfa, 0x0, 0x0, 0xe, + 0xfa, 0x0, 0x5f, 0xfc, 0x7f, 0xfa, 0x0, 0xe, + 0xff, 0x0, 0x0, 0x4f, 0xf4, 0x0, 0x5f, 0xfc, + 0x7f, 0xfa, 0x0, 0x9, 0xff, 0x50, 0x0, 0x9f, + 0xe0, 0x0, 0x5f, 0xfc, 0x7f, 0xfa, 0x0, 0x3, + 0xff, 0xa0, 0x0, 0xef, 0x90, 0x0, 0x5f, 0xfc, + 0x7f, 0xfa, 0x0, 0x0, 0xef, 0xf0, 0x4, 0xff, + 0x30, 0x0, 0x5f, 0xfc, 0x7f, 0xfa, 0x0, 0x0, + 0x8f, 0xf5, 0xa, 0xfe, 0x0, 0x0, 0x5f, 0xfc, + 0x7f, 0xfa, 0x0, 0x0, 0x3f, 0xfa, 0xf, 0xf8, + 0x0, 0x0, 0x5f, 0xfc, 0x7f, 0xfa, 0x0, 0x0, + 0xd, 0xff, 0x5f, 0xf3, 0x0, 0x0, 0x5f, 0xfc, + 0x7f, 0xfa, 0x0, 0x0, 0x8, 0xff, 0xef, 0xd0, + 0x0, 0x0, 0x5f, 0xfc, 0x7f, 0xfa, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x70, 0x0, 0x0, 0x5f, 0xfc, + 0x7f, 0xfa, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x20, + 0x0, 0x0, 0x5f, 0xfc, 0x7f, 0xfa, 0x0, 0x0, + 0x0, 0x7f, 0xfc, 0x0, 0x0, 0x0, 0x5f, 0xfc, + + /* U+004E "N" */ + 0x5f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xfd, 0x5f, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xfd, 0x5f, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfd, 0x5f, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfd, + 0x5f, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xfd, 0x5f, 0xfd, 0xef, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xfd, 0x5f, 0xfc, 0x4f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x3f, 0xfd, 0x5f, 0xfc, + 0x9, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x3f, 0xfd, + 0x5f, 0xfc, 0x0, 0xef, 0xfc, 0x0, 0x0, 0x0, + 0x3f, 0xfd, 0x5f, 0xfc, 0x0, 0x4f, 0xff, 0x70, + 0x0, 0x0, 0x3f, 0xfd, 0x5f, 0xfc, 0x0, 0x9, + 0xff, 0xf2, 0x0, 0x0, 0x3f, 0xfd, 0x5f, 0xfc, + 0x0, 0x0, 0xdf, 0xfc, 0x0, 0x0, 0x3f, 0xfd, + 0x5f, 0xfc, 0x0, 0x0, 0x3f, 0xff, 0x70, 0x0, + 0x3f, 0xfd, 0x5f, 0xfc, 0x0, 0x0, 0x8, 0xff, + 0xf2, 0x0, 0x3f, 0xfd, 0x5f, 0xfc, 0x0, 0x0, + 0x0, 0xdf, 0xfc, 0x0, 0x3f, 0xfd, 0x5f, 0xfc, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x80, 0x3f, 0xfd, + 0x5f, 0xfc, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf3, + 0x3f, 0xfd, 0x5f, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xfd, 0x4f, 0xfd, 0x5f, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xcf, 0xfd, 0x5f, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xfd, + 0x5f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xfd, 0x5f, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xfd, 0x5f, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xfd, 0x5f, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfd, + + /* U+004F "O" */ + 0x0, 0x0, 0x0, 0x2, 0x6b, 0xde, 0xfe, 0xc9, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x4e, 0xff, 0xff, 0xed, 0xce, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0x93, 0x0, 0x0, 0x16, 0xdf, 0xff, 0xb0, 0x0, + 0x0, 0x2f, 0xff, 0xd2, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf9, 0x0, 0x0, 0xcf, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x30, + 0x4, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xb0, 0xa, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf2, + 0xe, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf6, 0x2f, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfa, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xfc, 0x5f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfd, + 0x6f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xfd, 0x5f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfc, + 0x3f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xfa, 0xf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf6, + 0xa, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf2, 0x4, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xb0, + 0x0, 0xcf, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0x30, 0x0, 0x2f, 0xff, 0xd2, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf9, 0x0, + 0x0, 0x5, 0xff, 0xff, 0x82, 0x0, 0x0, 0x16, + 0xdf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x4e, 0xff, + 0xff, 0xed, 0xce, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x7b, 0xef, 0xfe, 0xc9, 0x40, 0x0, 0x0, 0x0, + + /* U+0050 "P" */ + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdb, 0x83, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x6f, 0xff, 0xee, 0xee, + 0xee, 0xee, 0xff, 0xff, 0xfb, 0x0, 0x6f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xcf, 0xff, 0x60, + 0x6f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xd0, 0x6f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xf1, 0x6f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf2, 0x6f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf2, + 0x6f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf0, 0x6f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xb0, 0x6f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x16, 0xef, 0xff, 0x30, 0x6f, 0xff, + 0xee, 0xee, 0xee, 0xef, 0xff, 0xff, 0xf8, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0xda, 0x61, 0x0, 0x0, 0x6f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0051 "Q" */ + 0x0, 0x0, 0x0, 0x2, 0x7b, 0xde, 0xfe, 0xc9, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1a, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4e, 0xff, 0xff, 0xed, 0xce, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf9, 0x30, 0x0, 0x0, 0x5d, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xd2, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xf9, 0x0, 0x0, 0xc, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xf4, 0x0, 0x4, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xc0, 0x0, + 0xaf, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x20, 0xe, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf7, + 0x3, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xa0, 0x4f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xfc, 0x5, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xd0, 0x5f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfd, 0x4, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xb0, 0x2f, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xfa, 0x0, 0xef, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x60, + 0xa, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf2, 0x0, 0x3f, 0xff, 0x40, + 0x0, 0x0, 0x1, 0xe9, 0x20, 0x0, 0xdf, 0xfb, + 0x0, 0x0, 0xbf, 0xfe, 0x10, 0x0, 0x0, 0x6f, + 0xff, 0x90, 0x9f, 0xff, 0x30, 0x0, 0x1, 0xef, + 0xfd, 0x20, 0x0, 0x4, 0xaf, 0xff, 0xef, 0xff, + 0x90, 0x0, 0x0, 0x4, 0xff, 0xff, 0x93, 0x0, + 0x0, 0x3e, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xfe, 0xdc, 0xef, 0xff, 0xff, + 0xfb, 0x20, 0x0, 0x0, 0x0, 0x1, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0xbf, 0xff, 0x91, 0x0, + 0x0, 0x0, 0x0, 0x27, 0xbd, 0xff, 0xec, 0x83, + 0x0, 0x7f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2a, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x30, + + /* U+0052 "R" */ + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xca, + 0x50, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc1, 0x0, 0x0, 0x4f, + 0xff, 0xbb, 0xbb, 0xbb, 0xbb, 0xbd, 0xff, 0xff, + 0xd0, 0x0, 0x4, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xaf, 0xff, 0x80, 0x0, 0x4f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfe, + 0x0, 0x4, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf1, 0x0, 0x4f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x20, + 0x4, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf1, 0x0, 0x4f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfc, 0x0, 0x4, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xdf, + 0xff, 0x40, 0x0, 0x4f, 0xff, 0xcc, 0xcc, 0xcc, + 0xcd, 0xef, 0xff, 0xff, 0x80, 0x0, 0x4, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x50, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x84, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf0, + 0x0, 0x1, 0x3a, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf6, 0x0, 0x0, 0x4, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xf2, 0x0, 0x0, 0x4f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xb0, 0x0, 0x4, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x50, 0x0, 0x4f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfe, + 0x10, 0x4, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf9, 0x0, 0x4f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf3, + 0x4, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xd0, + + /* U+0053 "S" */ + 0x0, 0x0, 0x2, 0x8c, 0xef, 0xfe, 0xc9, 0x30, + 0x0, 0x0, 0x0, 0x1, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x30, 0x0, 0x0, 0x1d, 0xff, 0xff, + 0xfd, 0xde, 0xff, 0xff, 0xf4, 0x0, 0x0, 0xbf, + 0xff, 0x82, 0x0, 0x0, 0x16, 0xef, 0xff, 0x10, + 0x3, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0x90, 0x7, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xe0, 0x8, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf1, 0x6, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x21, 0x0, + 0x1, 0xff, 0xfb, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xfc, 0x73, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xfc, 0x84, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2a, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x4, 0x8c, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0x8d, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3b, 0xff, 0xf4, 0x0, 0x11, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfa, + 0x6f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xfd, 0x4f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xfd, 0xf, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfb, 0x9, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, + 0x1, 0xef, 0xff, 0xd6, 0x20, 0x0, 0x3, 0x9f, + 0xff, 0xd0, 0x0, 0x2e, 0xff, 0xff, 0xff, 0xee, + 0xff, 0xff, 0xfd, 0x20, 0x0, 0x1, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xa1, 0x0, 0x0, 0x0, + 0x1, 0x7a, 0xde, 0xff, 0xeb, 0x82, 0x0, 0x0, + + /* U+0054 "T" */ + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x4, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf0, 0x3e, 0xee, 0xee, + 0xee, 0xef, 0xff, 0xee, 0xee, 0xee, 0xee, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0055 "U" */ + 0x4f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfd, 0x4f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, + 0x4f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfd, 0x4f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, + 0x4f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfd, 0x4f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, + 0x4f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfd, 0x4f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, 0x3f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfc, + 0x1f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xfa, 0xe, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf7, 0xa, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf4, 0x4, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xe0, + 0x0, 0xcf, 0xff, 0xc5, 0x10, 0x0, 0x27, 0xef, + 0xff, 0x50, 0x0, 0x2e, 0xff, 0xff, 0xff, 0xef, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x1, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x50, 0x0, 0x0, 0x0, + 0x3, 0x8c, 0xef, 0xff, 0xda, 0x50, 0x0, 0x0, + + /* U+0056 "V" */ + 0xaf, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x33, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xd0, 0xd, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xf6, 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x10, 0x1, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xa0, 0x0, 0xa, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xf3, 0x0, 0x0, 0x4f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfd, 0x0, + 0x0, 0x0, 0xef, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0x70, 0x0, 0x0, 0x7, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x7f, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf7, 0x0, + 0x0, 0x0, 0xd, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xd0, 0x0, 0x0, 0x3, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0x30, 0x0, + 0x0, 0x9f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf8, 0x0, 0x0, 0xe, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xe0, 0x0, 0x5, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0x40, 0x0, 0xbf, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xfa, 0x0, 0x1f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xf0, 0x7, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0x50, 0xcf, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xfb, + 0x2f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xf7, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, + + /* U+0057 "W" */ + 0x8f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf7, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf3, + 0xf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xe0, + 0xb, 0xff, 0x70, 0x0, 0x0, 0x0, 0xe, 0xfd, + 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xa0, + 0x7, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x2f, 0xf9, + 0x9f, 0xf4, 0x0, 0x0, 0x0, 0xb, 0xff, 0x60, + 0x2, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x7f, 0xf4, + 0x5f, 0xf9, 0x0, 0x0, 0x0, 0xf, 0xff, 0x10, + 0x0, 0xef, 0xf2, 0x0, 0x0, 0x0, 0xbf, 0xf0, + 0xf, 0xfd, 0x0, 0x0, 0x0, 0x3f, 0xfd, 0x0, + 0x0, 0xaf, 0xf6, 0x0, 0x0, 0x0, 0xff, 0xb0, + 0xc, 0xff, 0x20, 0x0, 0x0, 0x7f, 0xf8, 0x0, + 0x0, 0x5f, 0xfa, 0x0, 0x0, 0x5, 0xff, 0x70, + 0x7, 0xff, 0x70, 0x0, 0x0, 0xbf, 0xf4, 0x0, + 0x0, 0x1f, 0xfe, 0x0, 0x0, 0x9, 0xff, 0x20, + 0x3, 0xff, 0xb0, 0x0, 0x0, 0xef, 0xf0, 0x0, + 0x0, 0xd, 0xff, 0x20, 0x0, 0xe, 0xfe, 0x0, + 0x0, 0xef, 0xf0, 0x0, 0x3, 0xff, 0xb0, 0x0, + 0x0, 0x8, 0xff, 0x50, 0x0, 0x2f, 0xf9, 0x0, + 0x0, 0xaf, 0xf4, 0x0, 0x7, 0xff, 0x70, 0x0, + 0x0, 0x4, 0xff, 0x90, 0x0, 0x7f, 0xf5, 0x0, + 0x0, 0x5f, 0xf9, 0x0, 0xb, 0xff, 0x20, 0x0, + 0x0, 0x0, 0xff, 0xd0, 0x0, 0xbf, 0xf1, 0x0, + 0x0, 0x1f, 0xfd, 0x0, 0xe, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xf1, 0x0, 0xff, 0xc0, 0x0, + 0x0, 0xc, 0xff, 0x10, 0x2f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf4, 0x5, 0xff, 0x70, 0x0, + 0x0, 0x8, 0xff, 0x50, 0x6f, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xf8, 0x9, 0xff, 0x30, 0x0, + 0x0, 0x3, 0xff, 0x90, 0xaf, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xfc, 0xd, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xc0, 0xef, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0x1f, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xf2, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0x7f, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xf8, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xef, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xfe, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xf1, 0x0, 0x0, 0x0, + + /* U+0058 "X" */ + 0x6, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf6, 0x0, 0xa, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfa, 0x0, 0x0, + 0xd, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xfd, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x50, 0x0, 0x0, 0x3f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfe, 0x10, 0x0, + 0x1d, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xfb, 0x0, 0xb, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf7, 0x7, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xf4, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1d, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xd4, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xf3, 0x9, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf7, 0x0, 0xd, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xfc, + 0x0, 0x0, 0x3f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xfe, 0x10, 0x0, 0x0, 0x7f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x30, 0x0, 0x0, 0x3f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x1, 0xef, 0xfd, + 0x0, 0x0, 0x1e, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xfa, 0x0, 0xb, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf6, + 0x7, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf2, + + /* U+0059 "Y" */ + 0x9f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0x10, 0xdf, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x50, 0x3, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xa0, 0x0, 0x8, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xe1, 0x0, 0x0, 0xd, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xa0, 0x0, 0x0, + 0x1, 0xef, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x50, 0x0, 0x0, 0xaf, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xfe, 0x10, 0x0, 0x5f, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xf9, 0x0, 0x1e, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf3, 0x9, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xd3, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+005A "Z" */ + 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf7, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf7, 0x0, 0xde, 0xee, 0xee, + 0xee, 0xee, 0xee, 0xee, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xed, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdb, 0x6f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x6f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + + /* U+005B "[" */ + 0xbf, 0xff, 0xff, 0xdb, 0xff, 0xff, 0xfd, 0xbf, + 0xf9, 0x77, 0x6b, 0xff, 0x40, 0x0, 0xbf, 0xf4, + 0x0, 0xb, 0xff, 0x40, 0x0, 0xbf, 0xf4, 0x0, + 0xb, 0xff, 0x40, 0x0, 0xbf, 0xf4, 0x0, 0xb, + 0xff, 0x40, 0x0, 0xbf, 0xf4, 0x0, 0xb, 0xff, + 0x40, 0x0, 0xbf, 0xf4, 0x0, 0xb, 0xff, 0x40, + 0x0, 0xbf, 0xf4, 0x0, 0xb, 0xff, 0x40, 0x0, + 0xbf, 0xf4, 0x0, 0xb, 0xff, 0x40, 0x0, 0xbf, + 0xf4, 0x0, 0xb, 0xff, 0x40, 0x0, 0xbf, 0xf4, + 0x0, 0xb, 0xff, 0x40, 0x0, 0xbf, 0xf4, 0x0, + 0xb, 0xff, 0x40, 0x0, 0xbf, 0xf4, 0x0, 0xb, + 0xff, 0x40, 0x0, 0xbf, 0xf4, 0x0, 0xb, 0xff, + 0x40, 0x0, 0xbf, 0xf9, 0x77, 0x6b, 0xff, 0xff, + 0xfd, 0xbf, 0xff, 0xff, 0xd0, + + /* U+005C "\\" */ + 0xdf, 0x80, 0x0, 0x0, 0x0, 0x8f, 0xd0, 0x0, + 0x0, 0x0, 0x4f, 0xf2, 0x0, 0x0, 0x0, 0xf, + 0xf6, 0x0, 0x0, 0x0, 0xa, 0xfb, 0x0, 0x0, + 0x0, 0x6, 0xff, 0x0, 0x0, 0x0, 0x1, 0xff, + 0x50, 0x0, 0x0, 0x0, 0xcf, 0x90, 0x0, 0x0, + 0x0, 0x8f, 0xe0, 0x0, 0x0, 0x0, 0x3f, 0xf3, + 0x0, 0x0, 0x0, 0xe, 0xf7, 0x0, 0x0, 0x0, + 0x9, 0xfc, 0x0, 0x0, 0x0, 0x5, 0xff, 0x10, + 0x0, 0x0, 0x0, 0xff, 0x50, 0x0, 0x0, 0x0, + 0xbf, 0xa0, 0x0, 0x0, 0x0, 0x7f, 0xf0, 0x0, + 0x0, 0x0, 0x2f, 0xf3, 0x0, 0x0, 0x0, 0xd, + 0xf8, 0x0, 0x0, 0x0, 0x8, 0xfd, 0x0, 0x0, + 0x0, 0x4, 0xff, 0x20, 0x0, 0x0, 0x0, 0xff, + 0x60, 0x0, 0x0, 0x0, 0xaf, 0xb0, 0x0, 0x0, + 0x0, 0x6f, 0xf0, 0x0, 0x0, 0x0, 0x1f, 0xf4, + + /* U+005D "]" */ + 0x6f, 0xff, 0xff, 0xf3, 0x6f, 0xff, 0xff, 0xf3, + 0x37, 0x77, 0xef, 0xf3, 0x0, 0x0, 0xcf, 0xf3, + 0x0, 0x0, 0xcf, 0xf3, 0x0, 0x0, 0xcf, 0xf3, + 0x0, 0x0, 0xcf, 0xf3, 0x0, 0x0, 0xcf, 0xf3, + 0x0, 0x0, 0xcf, 0xf3, 0x0, 0x0, 0xcf, 0xf3, + 0x0, 0x0, 0xcf, 0xf3, 0x0, 0x0, 0xcf, 0xf3, + 0x0, 0x0, 0xcf, 0xf3, 0x0, 0x0, 0xcf, 0xf3, + 0x0, 0x0, 0xcf, 0xf3, 0x0, 0x0, 0xcf, 0xf3, + 0x0, 0x0, 0xcf, 0xf3, 0x0, 0x0, 0xcf, 0xf3, + 0x0, 0x0, 0xcf, 0xf3, 0x0, 0x0, 0xcf, 0xf3, + 0x0, 0x0, 0xcf, 0xf3, 0x0, 0x0, 0xcf, 0xf3, + 0x0, 0x0, 0xcf, 0xf3, 0x0, 0x0, 0xcf, 0xf3, + 0x0, 0x0, 0xcf, 0xf3, 0x0, 0x0, 0xcf, 0xf3, + 0x0, 0x0, 0xcf, 0xf3, 0x0, 0x0, 0xcf, 0xf3, + 0x37, 0x77, 0xef, 0xf3, 0x6f, 0xff, 0xff, 0xf3, + 0x6f, 0xff, 0xff, 0xf3, + + /* U+005E "^" */ + 0x0, 0x0, 0x0, 0x28, 0x82, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xfb, 0xdf, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xf5, 0x6f, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xe0, 0xf, 0xfc, 0x0, 0x0, + 0x0, 0x4, 0xff, 0x80, 0x9, 0xff, 0x30, 0x0, + 0x0, 0xb, 0xff, 0x20, 0x3, 0xff, 0xa0, 0x0, + 0x0, 0x2f, 0xfb, 0x0, 0x0, 0xcf, 0xf1, 0x0, + 0x0, 0x9f, 0xf5, 0x0, 0x0, 0x6f, 0xf8, 0x0, + 0x1, 0xff, 0xe0, 0x0, 0x0, 0xe, 0xfe, 0x0, + 0x7, 0xff, 0x80, 0x0, 0x0, 0x9, 0xff, 0x60, + 0xe, 0xff, 0x20, 0x0, 0x0, 0x2, 0xff, 0xd0, + + /* U+005F "_" */ + 0x2, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x22, 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf1, 0x3f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x10, + + /* U+0060 "`" */ + 0x2a, 0xaa, 0x60, 0x0, 0x9f, 0xff, 0x10, 0x0, + 0xbf, 0xf8, 0x0, 0x1, 0xdf, 0xf0, 0x0, 0x2, + 0xff, 0x70, + + /* U+0061 "a" */ + 0x0, 0x0, 0x4a, 0xdf, 0xff, 0xeb, 0x60, 0x0, + 0x0, 0x1, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xe3, + 0x0, 0x1, 0xef, 0xff, 0xa8, 0x78, 0xcf, 0xff, + 0xe0, 0x0, 0x9f, 0xfd, 0x10, 0x0, 0x0, 0x5f, + 0xff, 0x40, 0xf, 0xff, 0x30, 0x0, 0x0, 0x0, + 0xbf, 0xf7, 0x0, 0x68, 0x90, 0x0, 0x0, 0x0, + 0x7, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x2, 0x57, + 0x9c, 0xff, 0xff, 0x90, 0x0, 0x6, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x2d, 0xff, 0xff, + 0xfe, 0xc9, 0x47, 0xff, 0x90, 0x1e, 0xff, 0xe8, + 0x41, 0x0, 0x0, 0x7f, 0xf9, 0x7, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x9, 0xff, 0x90, 0xaf, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf9, 0xa, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x90, 0x7f, + 0xfe, 0x20, 0x0, 0x0, 0x5f, 0xff, 0xfa, 0x1, + 0xff, 0xff, 0x96, 0x68, 0xdf, 0xff, 0xff, 0xb0, + 0x4, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x2f, 0xfe, + 0x0, 0x1, 0x8d, 0xff, 0xec, 0x93, 0x0, 0xcf, + 0xf4, + + /* U+0062 "b" */ + 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf4, 0x6, 0xce, 0xfd, 0x93, 0x0, 0x0, + 0xbf, 0xf5, 0xcf, 0xff, 0xff, 0xff, 0x80, 0x0, + 0xbf, 0xfe, 0xff, 0xa7, 0x8c, 0xff, 0xf8, 0x0, + 0xbf, 0xff, 0xe2, 0x0, 0x0, 0x5f, 0xff, 0x40, + 0xbf, 0xff, 0x30, 0x0, 0x0, 0x8, 0xff, 0xc0, + 0xbf, 0xfa, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf2, + 0xbf, 0xf5, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf5, + 0xbf, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf7, + 0xbf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf8, + 0xbf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf8, + 0xbf, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf7, + 0xbf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf4, + 0xbf, 0xf7, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf0, + 0xbf, 0xff, 0x10, 0x0, 0x0, 0xa, 0xff, 0xa0, + 0xbf, 0xff, 0xd2, 0x0, 0x0, 0x8f, 0xff, 0x20, + 0xbf, 0xfd, 0xff, 0xa7, 0x8d, 0xff, 0xf5, 0x0, + 0xbf, 0xf2, 0xdf, 0xff, 0xff, 0xff, 0x50, 0x0, + 0xbf, 0xf1, 0x7, 0xdf, 0xfd, 0x81, 0x0, 0x0, + + /* U+0063 "c" */ + 0x0, 0x0, 0x28, 0xce, 0xfe, 0xb6, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xd3, 0x0, + 0x0, 0x9f, 0xff, 0xd9, 0x79, 0xef, 0xff, 0x20, + 0x5, 0xff, 0xf6, 0x0, 0x0, 0x1c, 0xff, 0xb0, + 0xd, 0xff, 0x80, 0x0, 0x0, 0x1, 0xff, 0xf2, + 0x3f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x9c, 0x92, + 0x6f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x3a, 0x84, + 0x3f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf7, + 0xd, 0xff, 0x60, 0x0, 0x0, 0x0, 0xef, 0xf3, + 0x5, 0xff, 0xf4, 0x0, 0x0, 0xb, 0xff, 0xb0, + 0x0, 0x9f, 0xff, 0xc8, 0x79, 0xef, 0xfe, 0x10, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xc2, 0x0, + 0x0, 0x0, 0x28, 0xce, 0xfe, 0xb5, 0x0, 0x0, + + /* U+0064 "d" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf8, + 0x0, 0x0, 0x4a, 0xef, 0xeb, 0x50, 0x7f, 0xf8, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xfa, 0x7f, 0xf8, + 0x0, 0xbf, 0xff, 0xb8, 0x8b, 0xff, 0xef, 0xf8, + 0x7, 0xff, 0xf4, 0x0, 0x0, 0x4f, 0xff, 0xf8, + 0xe, 0xff, 0x50, 0x0, 0x0, 0x6, 0xff, 0xf8, + 0x4f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf8, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf8, + 0xaf, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf8, + 0xbf, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf8, + 0xbf, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf8, + 0xaf, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf8, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf8, + 0x3f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf8, + 0xd, 0xff, 0x60, 0x0, 0x0, 0x3, 0xff, 0xf8, + 0x5, 0xff, 0xf5, 0x0, 0x0, 0x3e, 0xff, 0xf8, + 0x0, 0x9f, 0xff, 0xc8, 0x7b, 0xff, 0xdf, 0xf8, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xfc, 0x4f, 0xf8, + 0x0, 0x0, 0x39, 0xdf, 0xec, 0x60, 0x4f, 0xf8, + + /* U+0065 "e" */ + 0x0, 0x0, 0x17, 0xce, 0xfe, 0xc7, 0x10, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x6f, 0xff, 0xd9, 0x78, 0xdf, 0xff, + 0x70, 0x0, 0x3f, 0xff, 0x60, 0x0, 0x0, 0x5f, + 0xff, 0x30, 0xb, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x5f, 0xfb, 0x2, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xf1, 0x6f, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0x59, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf7, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x8a, 0xff, 0xb7, 0x77, + 0x77, 0x77, 0x77, 0x77, 0x74, 0x9f, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x10, 0x0, 0x3f, 0xff, + 0x10, 0x0, 0x0, 0x0, 0xe, 0xfd, 0x40, 0xdf, + 0xfa, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf1, 0x5, + 0xff, 0xf9, 0x0, 0x0, 0x5, 0xff, 0xf7, 0x0, + 0x8, 0xff, 0xfe, 0x97, 0x9c, 0xff, 0xfb, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x1, 0x7c, 0xef, 0xfd, 0x93, 0x0, + 0x0, + + /* U+0066 "f" */ + 0x0, 0x0, 0x3a, 0xef, 0xfd, 0x60, 0x0, 0x5f, + 0xff, 0xff, 0xf5, 0x0, 0xd, 0xff, 0xfd, 0xcd, + 0x20, 0x0, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x1f, + 0xfe, 0x0, 0x0, 0x0, 0x1, 0xff, 0xe0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xf5, 0xb, 0xff, + 0xff, 0xff, 0xff, 0x50, 0x35, 0x6f, 0xfe, 0x55, + 0x51, 0x0, 0x1, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x1f, 0xfe, 0x0, 0x0, 0x0, 0x1, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x1f, 0xfe, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x1f, 0xfe, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x1f, 0xfe, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x1f, 0xfe, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x1f, + 0xfe, 0x0, 0x0, 0x0, 0x1, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x1f, 0xfe, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xe0, 0x0, 0x0, + + /* U+0067 "g" */ + 0x0, 0x0, 0x4a, 0xdf, 0xec, 0x60, 0xf, 0xfb, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xfc, 0x2f, 0xfb, + 0x0, 0xbf, 0xff, 0xb8, 0x8b, 0xff, 0xdf, 0xfb, + 0x6, 0xff, 0xf4, 0x0, 0x0, 0x3e, 0xff, 0xfb, + 0xe, 0xff, 0x50, 0x0, 0x0, 0x4, 0xff, 0xfb, + 0x5f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfb, + 0x9f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfb, + 0xbf, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfb, + 0xcf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xfb, + 0xdf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xfb, + 0xbf, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfb, + 0x9f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfb, + 0x5f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfb, + 0xe, 0xff, 0x40, 0x0, 0x0, 0x3, 0xff, 0xfb, + 0x6, 0xff, 0xf4, 0x0, 0x0, 0x3e, 0xff, 0xfb, + 0x0, 0xbf, 0xff, 0xc8, 0x8b, 0xff, 0xff, 0xfb, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xfc, 0x6f, 0xfa, + 0x0, 0x0, 0x4a, 0xef, 0xec, 0x60, 0x6f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf8, + 0x17, 0x52, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf5, + 0x2f, 0xfd, 0x0, 0x0, 0x0, 0x1, 0xef, 0xf1, + 0xe, 0xff, 0x70, 0x0, 0x0, 0x1c, 0xff, 0xb0, + 0x6, 0xff, 0xfd, 0x97, 0x8b, 0xff, 0xfe, 0x10, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xc2, 0x0, + 0x0, 0x2, 0x8c, 0xef, 0xfd, 0xa4, 0x0, 0x0, + + /* U+0068 "h" */ + 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf4, 0x4, + 0xae, 0xfe, 0xc7, 0x0, 0xb, 0xff, 0x5a, 0xff, + 0xff, 0xff, 0xfd, 0x10, 0xbf, 0xfe, 0xff, 0xd9, + 0xad, 0xff, 0xfc, 0xb, 0xff, 0xfe, 0x40, 0x0, + 0x7, 0xff, 0xf3, 0xbf, 0xff, 0x20, 0x0, 0x0, + 0xc, 0xff, 0x6b, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x7f, 0xf9, 0xbf, 0xf6, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xab, 0xff, 0x50, 0x0, 0x0, 0x0, 0x5f, + 0xfa, 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xab, 0xff, 0x40, 0x0, 0x0, 0x0, 0x5f, 0xfa, + 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x5, 0xff, 0xab, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x5f, 0xfa, 0xbf, + 0xf4, 0x0, 0x0, 0x0, 0x5, 0xff, 0xab, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x5f, 0xfa, 0xbf, 0xf4, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xab, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x5f, 0xfa, 0xbf, 0xf4, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xab, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x5f, 0xfa, + + /* U+0069 "i" */ + 0xbf, 0xf4, 0xbf, 0xf4, 0xbf, 0xf4, 0x57, 0x71, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf4, 0xbf, 0xf4, + 0xbf, 0xf4, 0xbf, 0xf4, 0xbf, 0xf4, 0xbf, 0xf4, + 0xbf, 0xf4, 0xbf, 0xf4, 0xbf, 0xf4, 0xbf, 0xf4, + 0xbf, 0xf4, 0xbf, 0xf4, 0xbf, 0xf4, 0xbf, 0xf4, + 0xbf, 0xf4, 0xbf, 0xf4, 0xbf, 0xf4, 0xbf, 0xf4, + + /* U+006A "j" */ + 0x0, 0x0, 0xbf, 0xf4, 0x0, 0x0, 0xbf, 0xf4, + 0x0, 0x0, 0xbf, 0xf4, 0x0, 0x0, 0x57, 0x72, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xf4, 0x0, 0x0, 0xbf, 0xf4, + 0x0, 0x0, 0xbf, 0xf4, 0x0, 0x0, 0xbf, 0xf4, + 0x0, 0x0, 0xbf, 0xf4, 0x0, 0x0, 0xbf, 0xf4, + 0x0, 0x0, 0xbf, 0xf4, 0x0, 0x0, 0xbf, 0xf4, + 0x0, 0x0, 0xbf, 0xf4, 0x0, 0x0, 0xbf, 0xf4, + 0x0, 0x0, 0xbf, 0xf4, 0x0, 0x0, 0xbf, 0xf4, + 0x0, 0x0, 0xbf, 0xf4, 0x0, 0x0, 0xbf, 0xf4, + 0x0, 0x0, 0xbf, 0xf4, 0x0, 0x0, 0xbf, 0xf4, + 0x0, 0x0, 0xbf, 0xf4, 0x0, 0x0, 0xbf, 0xf4, + 0x0, 0x0, 0xbf, 0xf4, 0x0, 0x0, 0xbf, 0xf4, + 0x0, 0x0, 0xcf, 0xf2, 0x0, 0x1, 0xff, 0xf0, + 0xb, 0xae, 0xff, 0xc0, 0x3f, 0xff, 0xff, 0x40, + 0x5e, 0xff, 0xc4, 0x0, + + /* U+006B "k" */ + 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf4, 0x0, + 0x0, 0x3, 0xff, 0xfa, 0xb, 0xff, 0x40, 0x0, + 0x3, 0xef, 0xfa, 0x0, 0xbf, 0xf4, 0x0, 0x2, + 0xef, 0xfa, 0x0, 0xb, 0xff, 0x40, 0x2, 0xef, + 0xfa, 0x0, 0x0, 0xbf, 0xf4, 0x2, 0xef, 0xfa, + 0x0, 0x0, 0xb, 0xff, 0x41, 0xdf, 0xfa, 0x0, + 0x0, 0x0, 0xbf, 0xf5, 0xdf, 0xfb, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0xb, 0xff, 0xfa, 0x3f, 0xff, 0x40, 0x0, 0x0, + 0xbf, 0xf9, 0x0, 0x9f, 0xfe, 0x0, 0x0, 0xb, + 0xff, 0x40, 0x0, 0xef, 0xf9, 0x0, 0x0, 0xbf, + 0xf4, 0x0, 0x4, 0xff, 0xf4, 0x0, 0xb, 0xff, + 0x40, 0x0, 0xa, 0xff, 0xe0, 0x0, 0xbf, 0xf4, + 0x0, 0x0, 0x1e, 0xff, 0x90, 0xb, 0xff, 0x40, + 0x0, 0x0, 0x6f, 0xff, 0x30, 0xbf, 0xf4, 0x0, + 0x0, 0x0, 0xcf, 0xfd, 0xb, 0xff, 0x40, 0x0, + 0x0, 0x2, 0xff, 0xf8, + + /* U+006C "l" */ + 0xcf, 0xf3, 0xcf, 0xf3, 0xcf, 0xf3, 0xcf, 0xf3, + 0xcf, 0xf3, 0xcf, 0xf3, 0xcf, 0xf3, 0xcf, 0xf3, + 0xcf, 0xf3, 0xcf, 0xf3, 0xcf, 0xf3, 0xcf, 0xf3, + 0xcf, 0xf3, 0xcf, 0xf3, 0xcf, 0xf3, 0xcf, 0xf3, + 0xcf, 0xf3, 0xcf, 0xf3, 0xcf, 0xf3, 0xcf, 0xf3, + 0xcf, 0xf3, 0xcf, 0xf3, 0xcf, 0xf3, 0xcf, 0xf3, + + /* U+006D "m" */ + 0xcf, 0xe0, 0x6, 0xce, 0xfd, 0x92, 0x0, 0x2, + 0x9d, 0xfe, 0xc6, 0x0, 0xc, 0xfe, 0x1c, 0xff, + 0xff, 0xff, 0xf4, 0x5, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0xcf, 0xec, 0xff, 0xba, 0xcf, 0xff, 0xd5, + 0xff, 0xda, 0xae, 0xff, 0xf6, 0xc, 0xff, 0xfc, + 0x20, 0x0, 0x4f, 0xff, 0xff, 0x50, 0x0, 0xb, + 0xff, 0xc0, 0xcf, 0xff, 0x10, 0x0, 0x0, 0xaf, + 0xff, 0x70, 0x0, 0x0, 0x2f, 0xff, 0xc, 0xff, + 0x90, 0x0, 0x0, 0x6, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0xff, 0xf1, 0xcf, 0xf6, 0x0, 0x0, 0x0, + 0x5f, 0xfc, 0x0, 0x0, 0x0, 0xe, 0xff, 0x1c, + 0xff, 0x40, 0x0, 0x0, 0x4, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0xdf, 0xf1, 0xcf, 0xf3, 0x0, 0x0, + 0x0, 0x4f, 0xfb, 0x0, 0x0, 0x0, 0xd, 0xff, + 0x1c, 0xff, 0x30, 0x0, 0x0, 0x4, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0xdf, 0xf1, 0xcf, 0xf3, 0x0, + 0x0, 0x0, 0x4f, 0xfb, 0x0, 0x0, 0x0, 0xd, + 0xff, 0x1c, 0xff, 0x30, 0x0, 0x0, 0x4, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0xdf, 0xf1, 0xcf, 0xf3, + 0x0, 0x0, 0x0, 0x4f, 0xfb, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x1c, 0xff, 0x30, 0x0, 0x0, 0x4, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0xdf, 0xf1, 0xcf, + 0xf3, 0x0, 0x0, 0x0, 0x4f, 0xfb, 0x0, 0x0, + 0x0, 0xd, 0xff, 0x1c, 0xff, 0x30, 0x0, 0x0, + 0x4, 0xff, 0xb0, 0x0, 0x0, 0x0, 0xdf, 0xf1, + 0xcf, 0xf3, 0x0, 0x0, 0x0, 0x4f, 0xfb, 0x0, + 0x0, 0x0, 0xd, 0xff, 0x1c, 0xff, 0x30, 0x0, + 0x0, 0x4, 0xff, 0xb0, 0x0, 0x0, 0x0, 0xdf, + 0xf1, + + /* U+006E "n" */ + 0xbf, 0xf0, 0x4, 0xae, 0xfe, 0xb5, 0x0, 0xb, + 0xff, 0xa, 0xff, 0xff, 0xff, 0xfc, 0x10, 0xbf, + 0xfa, 0xff, 0xda, 0xad, 0xff, 0xfb, 0xb, 0xff, + 0xfe, 0x30, 0x0, 0x7, 0xff, 0xf3, 0xbf, 0xff, + 0x20, 0x0, 0x0, 0xd, 0xff, 0x7b, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x8f, 0xf9, 0xbf, 0xf7, 0x0, + 0x0, 0x0, 0x6, 0xff, 0x9b, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x5f, 0xfa, 0xbf, 0xf4, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xab, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x5f, 0xfa, 0xbf, 0xf4, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xab, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x5f, 0xfa, 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xab, 0xff, 0x40, 0x0, 0x0, 0x0, 0x5f, + 0xfa, 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xab, 0xff, 0x40, 0x0, 0x0, 0x0, 0x5f, 0xfa, + 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x5, 0xff, 0xab, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x5f, 0xfa, + + /* U+006F "o" */ + 0x0, 0x0, 0x17, 0xce, 0xfe, 0xc7, 0x10, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0xaf, 0xff, 0xd9, 0x79, 0xef, 0xff, + 0x80, 0x0, 0x7f, 0xff, 0x70, 0x0, 0x0, 0x8f, + 0xff, 0x40, 0xe, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x9f, 0xfd, 0x5, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf3, 0x9f, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0x7b, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf9, 0xcf, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xbc, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xfa, 0xbf, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0x99, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf7, 0x5f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x30, 0xef, + 0xf7, 0x0, 0x0, 0x0, 0x8, 0xff, 0xd0, 0x7, + 0xff, 0xf6, 0x0, 0x0, 0x8, 0xff, 0xf5, 0x0, + 0xa, 0xff, 0xfd, 0x87, 0x9d, 0xff, 0xf8, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x1, 0x8c, 0xef, 0xec, 0x71, 0x0, + 0x0, + + /* U+0070 "p" */ + 0xbf, 0xf0, 0x6, 0xce, 0xfd, 0x93, 0x0, 0x0, + 0xbf, 0xf1, 0xcf, 0xff, 0xff, 0xff, 0x90, 0x0, + 0xbf, 0xfc, 0xff, 0x96, 0x6b, 0xff, 0xf9, 0x0, + 0xbf, 0xff, 0xe2, 0x0, 0x0, 0x5f, 0xff, 0x40, + 0xbf, 0xff, 0x30, 0x0, 0x0, 0x7, 0xff, 0xc0, + 0xbf, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf2, + 0xbf, 0xf5, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf6, + 0xbf, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf8, + 0xbf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, + 0xbf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf8, + 0xbf, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf7, + 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf4, + 0xbf, 0xf9, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf1, + 0xbf, 0xff, 0x10, 0x0, 0x0, 0x9, 0xff, 0xa0, + 0xbf, 0xff, 0xc1, 0x0, 0x0, 0x8f, 0xff, 0x20, + 0xbf, 0xff, 0xff, 0xa7, 0x8d, 0xff, 0xf6, 0x0, + 0xbf, 0xf6, 0xdf, 0xff, 0xff, 0xff, 0x60, 0x0, + 0xbf, 0xf4, 0x7, 0xdf, 0xfd, 0x81, 0x0, 0x0, + 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0071 "q" */ + 0x0, 0x0, 0x4a, 0xef, 0xeb, 0x50, 0x2f, 0xf8, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xfa, 0x2f, 0xf8, + 0x0, 0xbf, 0xff, 0xa6, 0x6a, 0xff, 0xcf, 0xf8, + 0x7, 0xff, 0xe3, 0x0, 0x0, 0x3f, 0xff, 0xf8, + 0xe, 0xff, 0x50, 0x0, 0x0, 0x5, 0xff, 0xf8, + 0x4f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf8, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf8, + 0xaf, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf8, + 0xbf, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf8, + 0xbf, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xf8, + 0x9f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf8, + 0x6f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf8, + 0x2f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf8, + 0xc, 0xff, 0x70, 0x0, 0x0, 0x3, 0xff, 0xf8, + 0x3, 0xff, 0xf6, 0x0, 0x0, 0x3e, 0xff, 0xf8, + 0x0, 0x7f, 0xff, 0xc8, 0x7a, 0xff, 0xff, 0xf8, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xfc, 0x8f, 0xf8, + 0x0, 0x0, 0x29, 0xdf, 0xec, 0x50, 0x7f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf8, + + /* U+0072 "r" */ + 0xcf, 0xe0, 0x2b, 0xfe, 0xc5, 0xcf, 0xe2, 0xef, + 0xff, 0xf7, 0xcf, 0xec, 0xff, 0xff, 0xf2, 0xcf, + 0xff, 0xd4, 0x13, 0x80, 0xcf, 0xff, 0x20, 0x0, + 0x0, 0xcf, 0xfa, 0x0, 0x0, 0x0, 0xcf, 0xf6, + 0x0, 0x0, 0x0, 0xcf, 0xf4, 0x0, 0x0, 0x0, + 0xcf, 0xf3, 0x0, 0x0, 0x0, 0xcf, 0xf3, 0x0, + 0x0, 0x0, 0xcf, 0xf3, 0x0, 0x0, 0x0, 0xcf, + 0xf3, 0x0, 0x0, 0x0, 0xcf, 0xf3, 0x0, 0x0, + 0x0, 0xcf, 0xf3, 0x0, 0x0, 0x0, 0xcf, 0xf3, + 0x0, 0x0, 0x0, 0xcf, 0xf3, 0x0, 0x0, 0x0, + 0xcf, 0xf3, 0x0, 0x0, 0x0, 0xcf, 0xf3, 0x0, + 0x0, 0x0, + + /* U+0073 "s" */ + 0x0, 0x4, 0xae, 0xff, 0xeb, 0x71, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, 0xb, + 0xff, 0xfa, 0x87, 0x9e, 0xff, 0xf3, 0x3, 0xff, + 0xd1, 0x0, 0x0, 0xb, 0xff, 0xa0, 0x6f, 0xf7, + 0x0, 0x0, 0x0, 0x2f, 0xfd, 0x6, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x21, 0x0, 0x2f, 0xff, 0xc6, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xd8, 0x40, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xff, 0xfa, 0x20, 0x0, 0x0, 0x16, 0xbf, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x3, 0x7c, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xef, 0xf8, 0x8c, 0xe2, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xaa, 0xff, 0x80, 0x0, 0x0, 0x0, 0x8f, + 0xf9, 0x4f, 0xff, 0x50, 0x0, 0x0, 0x3f, 0xff, + 0x40, 0xaf, 0xff, 0xc9, 0x78, 0xcf, 0xff, 0xa0, + 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x39, 0xdf, 0xff, 0xd9, 0x30, 0x0, + + /* U+0074 "t" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6a, + 0x0, 0x0, 0x0, 0x1c, 0xfb, 0x0, 0x0, 0x0, + 0x4f, 0xfb, 0x0, 0x0, 0x0, 0x4f, 0xfb, 0x0, + 0x0, 0x0, 0x4f, 0xfb, 0x0, 0x0, 0x0, 0x4f, + 0xfb, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xb0, + 0x7f, 0xff, 0xff, 0xff, 0xb0, 0x25, 0x7f, 0xfc, + 0x55, 0x30, 0x0, 0x4f, 0xfb, 0x0, 0x0, 0x0, + 0x4f, 0xfb, 0x0, 0x0, 0x0, 0x4f, 0xfb, 0x0, + 0x0, 0x0, 0x4f, 0xfb, 0x0, 0x0, 0x0, 0x4f, + 0xfb, 0x0, 0x0, 0x0, 0x4f, 0xfb, 0x0, 0x0, + 0x0, 0x4f, 0xfb, 0x0, 0x0, 0x0, 0x4f, 0xfb, + 0x0, 0x0, 0x0, 0x4f, 0xfb, 0x0, 0x0, 0x0, + 0x4f, 0xfb, 0x0, 0x0, 0x0, 0x3f, 0xfc, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0x10, 0x0, 0x0, 0x1f, + 0xff, 0xec, 0xb0, 0x0, 0xa, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x7d, 0xff, 0xd0, + + /* U+0075 "u" */ + 0xcf, 0xf3, 0x0, 0x0, 0x0, 0x7, 0xff, 0x8c, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x7f, 0xf8, 0xcf, + 0xf3, 0x0, 0x0, 0x0, 0x7, 0xff, 0x8c, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x7f, 0xf8, 0xcf, 0xf3, + 0x0, 0x0, 0x0, 0x7, 0xff, 0x8c, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x7f, 0xf8, 0xcf, 0xf3, 0x0, + 0x0, 0x0, 0x7, 0xff, 0x8c, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x7f, 0xf8, 0xcf, 0xf3, 0x0, 0x0, + 0x0, 0x7, 0xff, 0x8c, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x7f, 0xf8, 0xcf, 0xf3, 0x0, 0x0, 0x0, + 0x8, 0xff, 0x8c, 0xff, 0x40, 0x0, 0x0, 0x0, + 0xaf, 0xf8, 0xbf, 0xf5, 0x0, 0x0, 0x0, 0xd, + 0xff, 0x89, 0xff, 0xa0, 0x0, 0x0, 0x5, 0xff, + 0xf8, 0x5f, 0xff, 0x50, 0x0, 0x4, 0xff, 0xff, + 0x80, 0xdf, 0xff, 0xc9, 0x9d, 0xff, 0x9f, 0xf8, + 0x2, 0xdf, 0xff, 0xff, 0xff, 0x72, 0xff, 0x80, + 0x0, 0x6c, 0xef, 0xd9, 0x20, 0x2f, 0xf8, + + /* U+0076 "v" */ + 0x6f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0x60, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf1, 0xa, 0xff, 0x70, 0x0, 0x0, 0x0, 0x5f, + 0xfa, 0x0, 0x4f, 0xfd, 0x0, 0x0, 0x0, 0xb, + 0xff, 0x40, 0x0, 0xef, 0xf2, 0x0, 0x0, 0x1, + 0xff, 0xe0, 0x0, 0x8, 0xff, 0x80, 0x0, 0x0, + 0x6f, 0xf9, 0x0, 0x0, 0x2f, 0xfd, 0x0, 0x0, + 0xc, 0xff, 0x30, 0x0, 0x0, 0xcf, 0xf3, 0x0, + 0x2, 0xff, 0xd0, 0x0, 0x0, 0x6, 0xff, 0x90, + 0x0, 0x8f, 0xf7, 0x0, 0x0, 0x0, 0xf, 0xfe, + 0x0, 0xd, 0xff, 0x10, 0x0, 0x0, 0x0, 0xaf, + 0xf4, 0x3, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0x90, 0x9f, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xfe, 0xe, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xf7, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xf1, 0x0, 0x0, + 0x0, + + /* U+0077 "w" */ + 0xaf, 0xf6, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x0, + 0x0, 0x0, 0xb, 0xff, 0x36, 0xff, 0xa0, 0x0, + 0x0, 0x9, 0xff, 0xf4, 0x0, 0x0, 0x0, 0xff, + 0xe0, 0x1f, 0xfe, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x80, 0x0, 0x0, 0x4f, 0xf9, 0x0, 0xcf, 0xf3, + 0x0, 0x0, 0x1f, 0xff, 0xfc, 0x0, 0x0, 0x9, + 0xff, 0x40, 0x7, 0xff, 0x70, 0x0, 0x6, 0xff, + 0xdf, 0xf0, 0x0, 0x0, 0xdf, 0xf0, 0x0, 0x2f, + 0xfb, 0x0, 0x0, 0xaf, 0xe7, 0xff, 0x40, 0x0, + 0x2f, 0xfa, 0x0, 0x0, 0xef, 0xf0, 0x0, 0xe, + 0xfa, 0x3f, 0xf8, 0x0, 0x7, 0xff, 0x50, 0x0, + 0x9, 0xff, 0x40, 0x2, 0xff, 0x60, 0xff, 0xc0, + 0x0, 0xbf, 0xf1, 0x0, 0x0, 0x4f, 0xf8, 0x0, + 0x7f, 0xf2, 0xb, 0xff, 0x0, 0xf, 0xfc, 0x0, + 0x0, 0x0, 0xff, 0xd0, 0xb, 0xfe, 0x0, 0x7f, + 0xf4, 0x5, 0xff, 0x70, 0x0, 0x0, 0xa, 0xff, + 0x10, 0xff, 0x90, 0x3, 0xff, 0x80, 0x9f, 0xf2, + 0x0, 0x0, 0x0, 0x6f, 0xf5, 0x3f, 0xf5, 0x0, + 0xf, 0xfc, 0xe, 0xfd, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xa7, 0xff, 0x10, 0x0, 0xbf, 0xf4, 0xff, + 0x80, 0x0, 0x0, 0x0, 0xc, 0xfe, 0xbf, 0xd0, + 0x0, 0x6, 0xff, 0xcf, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xf9, 0x0, 0x0, 0x2f, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x50, 0x0, 0x0, 0xef, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf1, 0x0, 0x0, 0xa, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xfd, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x0, 0x0, + 0x0, + + /* U+0078 "x" */ + 0xd, 0xff, 0xc0, 0x0, 0x0, 0x0, 0xaf, 0xfd, + 0x0, 0x3f, 0xff, 0x60, 0x0, 0x0, 0x5f, 0xff, + 0x30, 0x0, 0x8f, 0xff, 0x10, 0x0, 0x1e, 0xff, + 0x70, 0x0, 0x0, 0xdf, 0xfb, 0x0, 0xb, 0xff, + 0xc0, 0x0, 0x0, 0x3, 0xff, 0xf5, 0x6, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x7, 0xff, 0xe3, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf4, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xf7, 0x7, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0xaf, 0xfc, 0x0, 0xc, 0xff, 0xa0, 0x0, 0x0, + 0x5f, 0xff, 0x20, 0x0, 0x3f, 0xff, 0x50, 0x0, + 0x1e, 0xff, 0x80, 0x0, 0x0, 0x8f, 0xfe, 0x10, + 0xb, 0xff, 0xd0, 0x0, 0x0, 0x0, 0xdf, 0xfb, + 0x6, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf6, + + /* U+0079 "y" */ + 0x4f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0x80, 0xef, 0xf4, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xf2, 0x8, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x3f, + 0xfc, 0x0, 0x2f, 0xff, 0x0, 0x0, 0x0, 0x8, + 0xff, 0x60, 0x0, 0xcf, 0xf5, 0x0, 0x0, 0x0, + 0xef, 0xf1, 0x0, 0x6, 0xff, 0xb0, 0x0, 0x0, + 0x4f, 0xfa, 0x0, 0x0, 0xf, 0xff, 0x10, 0x0, + 0xa, 0xff, 0x40, 0x0, 0x0, 0xaf, 0xf6, 0x0, + 0x0, 0xff, 0xe0, 0x0, 0x0, 0x4, 0xff, 0xc0, + 0x0, 0x6f, 0xf8, 0x0, 0x0, 0x0, 0xe, 0xff, + 0x20, 0xb, 0xff, 0x20, 0x0, 0x0, 0x0, 0x8f, + 0xf7, 0x1, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xc0, 0x6f, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0x1b, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xf7, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xfe, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfc, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+007A "z" */ + 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xb0, 0x3, 0x55, 0x55, 0x55, 0x55, 0x59, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xfc, 0x78, 0x88, 0x99, 0x99, 0x99, 0x92, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x45, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf4, + + /* U+007B "{" */ + 0x0, 0x0, 0x0, 0x5b, 0xef, 0x90, 0x0, 0x0, + 0x7f, 0xff, 0xf9, 0x0, 0x0, 0x1f, 0xff, 0xca, + 0x50, 0x0, 0x5, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x7f, 0xf4, 0x0, 0x0, 0x0, 0x8, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x9f, 0xf3, 0x0, 0x0, 0x0, + 0x9, 0xff, 0x30, 0x0, 0x0, 0x0, 0x9f, 0xf2, + 0x0, 0x0, 0x0, 0xa, 0xff, 0x20, 0x0, 0x0, + 0x0, 0xbf, 0xf1, 0x0, 0x0, 0x0, 0xe, 0xfe, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xa0, 0x0, 0x0, + 0x4, 0xef, 0xf2, 0x0, 0x0, 0xf, 0xff, 0xe3, + 0x0, 0x0, 0x0, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x1, 0xcf, + 0xf3, 0x0, 0x0, 0x0, 0x2, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf1, 0x0, 0x0, 0x0, 0xa, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x9f, 0xf3, 0x0, 0x0, 0x0, + 0x9, 0xff, 0x30, 0x0, 0x0, 0x0, 0x9f, 0xf3, + 0x0, 0x0, 0x0, 0x8, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x7f, 0xf4, 0x0, 0x0, 0x0, 0x5, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xc9, 0x50, + 0x0, 0x0, 0x6f, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x6c, 0xff, 0x90, + + /* U+007C "|" */ + 0xef, 0xbe, 0xfb, 0xef, 0xbe, 0xfb, 0xef, 0xbe, + 0xfb, 0xef, 0xbe, 0xfb, 0xef, 0xbe, 0xfb, 0xef, + 0xbe, 0xfb, 0xef, 0xbe, 0xfb, 0xef, 0xbe, 0xfb, + 0xef, 0xbe, 0xfb, 0xef, 0xbe, 0xfb, 0xef, 0xbe, + 0xfb, 0xef, 0xbe, 0xfb, 0xef, 0xbe, 0xfb, 0xef, + 0xbe, 0xfb, 0xef, 0xbe, 0xfb, 0xef, 0xb0, + + /* U+007D "}" */ + 0x3f, 0xfd, 0x90, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x29, 0xbf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x4f, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0xe, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xe0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xf1, 0x0, 0x0, 0x0, 0x8, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x4f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xf7, 0x10, 0x0, 0x0, 0x1, + 0xbf, 0xff, 0x60, 0x0, 0x0, 0x1, 0xcf, 0xf6, + 0x0, 0x0, 0x2, 0xef, 0xfd, 0x40, 0x0, 0x0, + 0xdf, 0xf4, 0x0, 0x0, 0x0, 0x5f, 0xf8, 0x0, + 0x0, 0x0, 0x9, 0xff, 0x30, 0x0, 0x0, 0x0, + 0xbf, 0xf1, 0x0, 0x0, 0x0, 0xc, 0xff, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xe0, + 0x0, 0x0, 0x0, 0xd, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x4f, 0xfa, + 0x0, 0x0, 0x29, 0xbf, 0xff, 0x60, 0x0, 0x3, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x3f, 0xed, 0x70, + 0x0, 0x0, 0x0, + + /* U+007E "~" */ + 0x0, 0x0, 0x11, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xaf, 0xff, 0xfb, 0x71, 0x0, 0x0, + 0x0, 0x66, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xc6, + 0x32, 0x5c, 0xf6, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf6, 0x9f, 0x92, 0x1, 0x49, + 0xff, 0xff, 0xff, 0xff, 0xe3, 0x73, 0x0, 0x0, + 0x0, 0x4, 0xad, 0xff, 0xc7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00A0 " " */ + + /* U+00A3 "£" */ + 0x0, 0x0, 0x0, 0x5a, 0xdf, 0xfe, 0xa5, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xdf, 0xff, 0xff, 0xff, + 0xfc, 0x20, 0x0, 0x0, 0x3, 0xff, 0xff, 0xa7, + 0x7b, 0xff, 0xfe, 0x10, 0x0, 0x0, 0xdf, 0xfd, + 0x10, 0x0, 0x2, 0xef, 0xfa, 0x0, 0x0, 0x4f, + 0xff, 0x10, 0x0, 0x0, 0x2, 0xff, 0xf1, 0x0, + 0x7, 0xff, 0xb0, 0x0, 0x0, 0x0, 0xb, 0xfd, + 0x30, 0x0, 0x7f, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x17, 0x77, 0xff, 0xf9, 0x77, 0x76, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xed, 0xff, 0xda, 0x73, 0x0, 0x3, 0x92, 0x5, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xef, 0xff, + 0x80, 0xe, 0xff, 0xc8, 0x78, 0xbf, 0xff, 0xff, + 0xff, 0xfd, 0x0, 0x89, 0x10, 0x0, 0x0, 0x4, + 0x8c, 0xff, 0xc8, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00A4 "¤" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6c, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1d, + 0x40, 0x5f, 0xfc, 0x5, 0xbe, 0xfe, 0xb4, 0x1d, + 0xff, 0x42, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd1, 0x2, 0xef, 0xff, 0xfd, 0xbd, 0xff, + 0xff, 0xd1, 0x0, 0x9, 0xff, 0xd2, 0x0, 0x4, + 0xef, 0xf8, 0x0, 0x1, 0xff, 0xe1, 0x0, 0x0, + 0x2, 0xff, 0xf0, 0x0, 0x6f, 0xf6, 0x0, 0x0, + 0x0, 0x8, 0xff, 0x40, 0x8, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x5f, 0xf7, 0x0, 0x8f, 0xf2, 0x0, + 0x0, 0x0, 0x5, 0xff, 0x70, 0x6, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x8f, 0xf4, 0x0, 0x1f, 0xfe, + 0x10, 0x0, 0x0, 0x2f, 0xff, 0x0, 0x0, 0x9f, + 0xfd, 0x20, 0x0, 0x4e, 0xff, 0x80, 0x0, 0x2e, + 0xff, 0xff, 0xdb, 0xdf, 0xff, 0xfd, 0x10, 0x2e, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x15, + 0xff, 0xc0, 0x5b, 0xef, 0xea, 0x41, 0xdf, 0xf4, + 0x6, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xd4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+00A5 "¥" */ + 0xbf, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0x92, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xe1, 0x8, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xf6, 0x0, 0xe, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x9f, 0xfd, 0x0, 0x0, 0x5f, + 0xfe, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x40, 0x0, + 0x0, 0xcf, 0xf8, 0x0, 0x0, 0xb, 0xff, 0xa0, + 0x0, 0x0, 0x3, 0xff, 0xf1, 0x0, 0x4, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x9, 0xff, 0xa0, 0x0, + 0xcf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0x30, 0x5f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfc, 0xe, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xfa, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x67, 0x77, 0x7a, 0xff, 0xff, 0xfa, 0x77, + 0x77, 0x50, 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x0, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x0, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd0, 0x4, 0x44, 0x44, 0x44, 0xff, + 0xf4, 0x44, 0x44, 0x43, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0x0, 0x0, 0x0, 0x0, + + /* U+00A6 "¦" */ + 0xef, 0xbe, 0xfb, 0xef, 0xbe, 0xfb, 0xef, 0xbe, + 0xfb, 0xef, 0xbe, 0xfb, 0xef, 0xbe, 0xfb, 0xef, + 0xbe, 0xfb, 0xef, 0xb1, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x11, 0xef, 0xbe, 0xfb, 0xef, 0xbe, + 0xfb, 0xef, 0xbe, 0xfb, 0xef, 0xbe, 0xfb, 0xef, + 0xbe, 0xfb, 0xef, 0xbe, 0xfb, 0xef, 0xb0, + + /* U+00A7 "§" */ + 0x0, 0x0, 0x18, 0xdf, 0xfe, 0xb6, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xfd, 0x10, + 0x0, 0x0, 0x2f, 0xff, 0xe9, 0x7a, 0xff, 0xfd, + 0x0, 0x0, 0xa, 0xff, 0xa0, 0x0, 0x3, 0xff, + 0xf6, 0x0, 0x0, 0xef, 0xf0, 0x0, 0x0, 0x8, + 0xff, 0xc0, 0x0, 0xf, 0xff, 0x0, 0x0, 0x0, + 0x3e, 0xca, 0x0, 0x0, 0xbf, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfd, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x2, 0x9f, 0xff, + 0xff, 0x91, 0x0, 0x0, 0x0, 0x3, 0xef, 0xe6, + 0xdf, 0xff, 0xe5, 0x0, 0x0, 0x1, 0xef, 0xe1, + 0x0, 0x9f, 0xff, 0xfb, 0x10, 0x0, 0x6f, 0xf5, + 0x0, 0x0, 0x3d, 0xff, 0xfe, 0x40, 0x9, 0xff, + 0x20, 0x0, 0x0, 0x8, 0xff, 0xff, 0x40, 0x8f, + 0xf6, 0x0, 0x0, 0x0, 0x3, 0xef, 0xfe, 0x3, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf4, + 0xb, 0xff, 0xd3, 0x0, 0x0, 0x0, 0x9, 0xff, + 0x60, 0xc, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x7f, + 0xf4, 0x0, 0x9, 0xff, 0xfe, 0x50, 0x0, 0xb, + 0xfe, 0x0, 0x0, 0x4, 0xdf, 0xff, 0xb1, 0x8, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xec, + 0xfb, 0x30, 0x0, 0x0, 0x0, 0x0, 0x2c, 0xff, + 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xef, 0xfb, 0x0, 0x0, 0x2, 0x20, 0x0, + 0x0, 0x2, 0xff, 0xf1, 0x0, 0x6f, 0xfb, 0x0, + 0x0, 0x0, 0xc, 0xff, 0x30, 0x4, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0xef, 0xf3, 0x0, 0xd, 0xff, + 0xc1, 0x0, 0x0, 0x9f, 0xfe, 0x0, 0x0, 0x4f, + 0xff, 0xfb, 0x8a, 0xef, 0xff, 0x50, 0x0, 0x0, + 0x4e, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x17, 0xce, 0xff, 0xd8, 0x20, 0x0, 0x0, + + /* U+00A8 "¨" */ + 0x66, 0x60, 0x0, 0x46, 0x62, 0xff, 0xf2, 0x0, + 0xcf, 0xf5, 0xff, 0xf2, 0x0, 0xcf, 0xf5, 0xff, + 0xf2, 0x0, 0xcf, 0xf5, + + /* U+00A9 "©" */ + 0x0, 0x0, 0x0, 0x0, 0x49, 0xce, 0xfe, 0xda, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6e, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2d, 0xff, 0xd8, 0x42, + 0x12, 0x48, 0xdf, 0xfd, 0x20, 0x0, 0x0, 0x0, + 0x3, 0xef, 0xe6, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xef, 0xe3, 0x0, 0x0, 0x0, 0x2e, 0xfc, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1b, 0xfe, 0x20, + 0x0, 0x0, 0xcf, 0xc0, 0x0, 0x2, 0x8b, 0xdc, + 0x93, 0x0, 0x0, 0xbf, 0xd0, 0x0, 0x7, 0xfe, + 0x10, 0x0, 0x8f, 0xff, 0xff, 0xff, 0x90, 0x0, + 0xe, 0xf7, 0x0, 0xe, 0xf6, 0x0, 0x8, 0xff, + 0x92, 0x1, 0x7f, 0xf8, 0x0, 0x5, 0xff, 0x10, + 0x5f, 0xd0, 0x0, 0x2f, 0xf7, 0x0, 0x0, 0x4, + 0xff, 0x10, 0x0, 0xdf, 0x50, 0x9f, 0x80, 0x0, + 0x8f, 0xd0, 0x0, 0x0, 0x0, 0x86, 0x10, 0x0, + 0x7f, 0xa0, 0xdf, 0x40, 0x0, 0xdf, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xd0, 0xff, + 0x20, 0x0, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xf0, 0xff, 0x10, 0x0, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xf0, 0xef, 0x20, 0x0, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf0, 0xdf, 0x40, + 0x0, 0xcf, 0x70, 0x0, 0x0, 0x0, 0x21, 0x0, + 0x0, 0x3f, 0xd0, 0x9f, 0x80, 0x0, 0x8f, 0xc0, + 0x0, 0x0, 0x0, 0xcf, 0x60, 0x0, 0x7f, 0xa0, + 0x5f, 0xd0, 0x0, 0x2f, 0xf5, 0x0, 0x0, 0x6, + 0xff, 0x20, 0x0, 0xcf, 0x50, 0xe, 0xf6, 0x0, + 0x8, 0xff, 0x81, 0x2, 0x9f, 0xf9, 0x0, 0x5, + 0xfe, 0x0, 0x6, 0xfe, 0x10, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x1d, 0xf7, 0x0, 0x0, + 0xdf, 0xc0, 0x0, 0x4, 0xad, 0xee, 0xa4, 0x0, + 0x0, 0xbf, 0xd0, 0x0, 0x0, 0x1e, 0xfc, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1c, 0xfe, 0x20, + 0x0, 0x0, 0x3, 0xef, 0xe6, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xef, 0xe3, 0x0, 0x0, 0x0, 0x0, + 0x1d, 0xff, 0xd8, 0x42, 0x12, 0x48, 0xdf, 0xfd, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6e, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x59, 0xde, 0xfe, 0xda, + 0x50, 0x0, 0x0, 0x0, 0x0, + + /* U+00AA "ª" */ + 0x0, 0x8, 0xdf, 0xe9, 0x14, 0xff, 0x10, 0xc, + 0xff, 0xee, 0xfd, 0xaf, 0xd0, 0x9, 0xff, 0x50, + 0x7, 0xff, 0xf9, 0x1, 0xff, 0xa0, 0x0, 0xc, + 0xff, 0x60, 0x4f, 0xf4, 0x0, 0x0, 0x6f, 0xf2, + 0x6, 0xff, 0x20, 0x0, 0x4, 0xff, 0x0, 0x7f, + 0xf1, 0x0, 0x0, 0x3f, 0xd0, 0x6, 0xff, 0x20, + 0x0, 0x5, 0xff, 0x0, 0x4f, 0xf4, 0x0, 0x0, + 0x8f, 0xf2, 0x0, 0xff, 0xa0, 0x0, 0xe, 0xff, + 0x50, 0x8, 0xff, 0x40, 0x9, 0xff, 0xf9, 0x0, + 0xc, 0xff, 0xef, 0xfe, 0xaf, 0xd0, 0x0, 0x8, + 0xef, 0xe9, 0x14, 0xff, 0x20, + + /* U+00AB "«" */ + 0x0, 0x0, 0x0, 0x21, 0x0, 0x0, 0x22, 0x0, + 0x0, 0x0, 0xdf, 0xb0, 0x0, 0x6f, 0xf2, 0x0, + 0x0, 0x8f, 0xf2, 0x0, 0x2f, 0xf9, 0x0, 0x0, + 0x4f, 0xf8, 0x0, 0xc, 0xfe, 0x10, 0x0, 0xe, + 0xfe, 0x0, 0x7, 0xff, 0x60, 0x0, 0xa, 0xff, + 0x60, 0x3, 0xff, 0xd0, 0x0, 0x5, 0xff, 0xd0, + 0x0, 0xdf, 0xf4, 0x0, 0x1, 0xef, 0xf4, 0x0, + 0x8f, 0xfa, 0x0, 0x0, 0x8f, 0xfd, 0x0, 0xf, + 0xff, 0x40, 0x0, 0x1, 0xef, 0xf5, 0x0, 0x7f, + 0xfc, 0x0, 0x0, 0x4, 0xff, 0xd0, 0x0, 0xcf, + 0xf5, 0x0, 0x0, 0x8, 0xff, 0x70, 0x2, 0xff, + 0xe0, 0x0, 0x0, 0xd, 0xff, 0x10, 0x6, 0xff, + 0x70, 0x0, 0x0, 0x2f, 0xf9, 0x0, 0xb, 0xff, + 0x10, 0x0, 0x0, 0x7f, 0xf2, 0x0, 0x1e, 0xfa, + 0x0, 0x0, 0x0, 0xbf, 0xb0, 0x0, 0x5f, 0xf3, + + /* U+00AC "¬" */ + 0x1c, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, + 0xc1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, + + /* U+00AD "­" */ + 0xef, 0xff, 0xff, 0xff, 0xf4, 0xef, 0xff, 0xff, + 0xff, 0xf4, 0xef, 0xff, 0xff, 0xff, 0xf4, + + /* U+00AE "®" */ + 0x0, 0x0, 0x0, 0x0, 0x49, 0xce, 0xfe, 0xda, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6e, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2d, 0xff, 0xd8, 0x42, + 0x12, 0x48, 0xdf, 0xfd, 0x20, 0x0, 0x0, 0x0, + 0x3, 0xef, 0xe6, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xef, 0xe3, 0x0, 0x0, 0x0, 0x2e, 0xfc, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1b, 0xfe, 0x20, + 0x0, 0x0, 0xcf, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xd0, 0x0, 0x7, 0xfe, + 0x10, 0xf, 0xff, 0xff, 0xfe, 0xc6, 0x0, 0x0, + 0xe, 0xf7, 0x0, 0xe, 0xf6, 0x0, 0xf, 0xfd, + 0xdd, 0xdf, 0xff, 0x90, 0x0, 0x5, 0xff, 0x10, + 0x5f, 0xd0, 0x0, 0xf, 0xf3, 0x0, 0x0, 0x8f, + 0xf2, 0x0, 0x0, 0xdf, 0x50, 0x9f, 0x80, 0x0, + 0xf, 0xf3, 0x0, 0x0, 0xf, 0xf6, 0x0, 0x0, + 0x7f, 0xa0, 0xdf, 0x40, 0x0, 0xf, 0xf3, 0x0, + 0x0, 0xf, 0xf5, 0x0, 0x0, 0x3f, 0xd0, 0xff, + 0x20, 0x0, 0xf, 0xf3, 0x0, 0x3, 0xbf, 0xe0, + 0x0, 0x0, 0x1f, 0xf0, 0xff, 0x10, 0x0, 0xf, + 0xff, 0xff, 0xff, 0xfd, 0x30, 0x0, 0x0, 0xf, + 0xf0, 0xef, 0x20, 0x0, 0xf, 0xfe, 0xef, 0xfe, + 0x60, 0x0, 0x0, 0x0, 0x1f, 0xf0, 0xdf, 0x40, + 0x0, 0xf, 0xf3, 0x0, 0x9f, 0xc1, 0x0, 0x0, + 0x0, 0x3f, 0xd0, 0x9f, 0x80, 0x0, 0xf, 0xf3, + 0x0, 0xa, 0xfb, 0x0, 0x0, 0x0, 0x7f, 0xa0, + 0x5f, 0xd0, 0x0, 0xf, 0xf3, 0x0, 0x1, 0xef, + 0x70, 0x0, 0x0, 0xcf, 0x50, 0xe, 0xf6, 0x0, + 0xf, 0xf3, 0x0, 0x0, 0x6f, 0xf2, 0x0, 0x5, + 0xfe, 0x0, 0x6, 0xfe, 0x10, 0xf, 0xf3, 0x0, + 0x0, 0xd, 0xfb, 0x0, 0x1d, 0xf7, 0x0, 0x0, + 0xdf, 0xc0, 0x7, 0x71, 0x0, 0x0, 0x3, 0x77, + 0x10, 0xbf, 0xd0, 0x0, 0x0, 0x1e, 0xfc, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1c, 0xfe, 0x20, + 0x0, 0x0, 0x3, 0xef, 0xe6, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xef, 0xe3, 0x0, 0x0, 0x0, 0x0, + 0x1d, 0xff, 0xd8, 0x42, 0x12, 0x48, 0xdf, 0xfd, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6e, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x59, 0xde, 0xfe, 0xda, + 0x50, 0x0, 0x0, 0x0, 0x0, + + /* U+00B0 "°" */ + 0x0, 0x6c, 0xfe, 0xa2, 0x0, 0x9, 0xff, 0xde, + 0xff, 0x30, 0x5f, 0xd2, 0x0, 0x6f, 0xe0, 0xaf, + 0x30, 0x0, 0xa, 0xf4, 0xcf, 0x0, 0x0, 0x7, + 0xf6, 0xaf, 0x40, 0x0, 0xa, 0xf4, 0x5f, 0xd2, + 0x0, 0x6f, 0xe0, 0x9, 0xff, 0xde, 0xff, 0x30, + 0x0, 0x6c, 0xfe, 0xa2, 0x0, + + /* U+00B1 "±" */ + 0x0, 0x0, 0x0, 0x0, 0x11, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0x50, 0x0, 0x0, 0x1, 0xcc, 0xcc, 0xcc, 0xef, + 0xfd, 0xcc, 0xcc, 0xcb, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf1, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x7, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1c, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, + 0xcc, 0xc1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf0, + + /* U+00B2 "²" */ + 0x0, 0x29, 0xdf, 0xfd, 0x81, 0x0, 0x2e, 0xff, + 0xff, 0xff, 0xd1, 0xc, 0xfe, 0x30, 0x18, 0xff, + 0x71, 0xce, 0x70, 0x0, 0xf, 0xfa, 0x0, 0x0, + 0x0, 0x1, 0xff, 0x80, 0x0, 0x0, 0x0, 0xbf, + 0xf2, 0x0, 0x0, 0x1, 0xcf, 0xf8, 0x0, 0x0, + 0x3, 0xef, 0xf8, 0x0, 0x0, 0x6, 0xff, 0xf5, + 0x0, 0x0, 0x7, 0xff, 0xd3, 0x0, 0x0, 0x6, + 0xff, 0xc1, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xb0, + + /* U+00B3 "³" */ + 0x0, 0x3a, 0xef, 0xec, 0x60, 0x0, 0x4f, 0xff, + 0xef, 0xff, 0x90, 0xd, 0xfd, 0x10, 0xc, 0xff, + 0x0, 0x58, 0x30, 0x0, 0x8f, 0xf1, 0x0, 0x0, + 0x0, 0x1d, 0xfc, 0x0, 0x0, 0x1, 0xdf, 0xfa, + 0x10, 0x0, 0x0, 0x5f, 0xff, 0xd4, 0x0, 0x0, + 0x0, 0x1, 0x9f, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0xef, 0x93, 0xac, 0x10, 0x0, 0xf, 0xfa, 0x1f, + 0xfc, 0x20, 0x2b, 0xff, 0x60, 0x6f, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x3a, 0xdf, 0xfc, 0x60, 0x0, + + /* U+00B5 "µ" */ + 0xaf, 0xf4, 0x0, 0x0, 0x0, 0x6, 0xff, 0x9a, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x6f, 0xf9, 0xaf, + 0xf4, 0x0, 0x0, 0x0, 0x6, 0xff, 0x9a, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x6f, 0xf9, 0xaf, 0xf4, + 0x0, 0x0, 0x0, 0x6, 0xff, 0x9a, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x6f, 0xf9, 0xaf, 0xf4, 0x0, + 0x0, 0x0, 0x6, 0xff, 0x9a, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x6f, 0xf9, 0xaf, 0xf4, 0x0, 0x0, + 0x0, 0x6, 0xff, 0x9a, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x6f, 0xf9, 0xaf, 0xf5, 0x0, 0x0, 0x0, + 0x7, 0xff, 0x9a, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x9f, 0xf9, 0xaf, 0xfa, 0x0, 0x0, 0x0, 0xc, + 0xff, 0x9a, 0xff, 0xf2, 0x0, 0x0, 0x4, 0xff, + 0xf9, 0xaf, 0xff, 0xd3, 0x0, 0x5, 0xff, 0xff, + 0x9a, 0xff, 0xff, 0xfd, 0xbe, 0xff, 0xef, 0xf9, + 0xaf, 0xf7, 0xff, 0xff, 0xff, 0xe4, 0xff, 0x9a, + 0xff, 0x41, 0x9e, 0xfe, 0x91, 0x1f, 0xf9, 0xaf, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+00B6 "¶" */ + 0x0, 0x0, 0x28, 0xce, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf4, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x8f, 0xff, 0xff, + 0xff, 0xee, 0xee, 0xff, 0xfe, 0xe4, 0x3, 0xff, + 0xff, 0xff, 0xff, 0x60, 0x0, 0xef, 0xe0, 0x0, + 0xa, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0xef, + 0xe0, 0x0, 0xe, 0xff, 0xff, 0xff, 0xff, 0x60, + 0x0, 0xef, 0xe0, 0x0, 0xf, 0xff, 0xff, 0xff, + 0xff, 0x60, 0x0, 0xef, 0xe0, 0x0, 0xf, 0xff, + 0xff, 0xff, 0xff, 0x60, 0x0, 0xef, 0xe0, 0x0, + 0xe, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0xef, + 0xe0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0x60, + 0x0, 0xef, 0xe0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xff, 0x60, 0x0, 0xef, 0xe0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xff, 0x60, 0x0, 0xef, 0xe0, 0x0, + 0x0, 0x5, 0xef, 0xff, 0xff, 0x60, 0x0, 0xef, + 0xe0, 0x0, 0x0, 0x0, 0x5, 0x8c, 0xff, 0x60, + 0x0, 0xef, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0x60, 0x0, 0xef, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0x60, 0x0, 0xef, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0x60, 0x0, 0xef, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0x60, + 0x0, 0xef, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0x60, 0x0, 0xef, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0x60, 0x0, 0xef, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0x60, 0x0, 0xef, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0x60, + 0x0, 0xef, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0x60, 0x0, 0xef, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0x60, 0x0, 0xef, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0x60, 0x0, 0xef, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0x60, + 0x0, 0xef, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0x60, 0x0, 0xef, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0x60, 0x0, 0xef, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0x60, 0x0, 0xef, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0x60, + 0x0, 0xef, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0x60, 0x0, 0xef, 0xe0, 0x0, + + /* U+00B7 "·" */ + 0x56, 0x62, 0xff, 0xf7, 0xff, 0xf7, 0xff, 0xf7, + + /* U+00BB "»" */ + 0x12, 0x10, 0x0, 0x2, 0x20, 0x0, 0x0, 0x3, + 0xff, 0x50, 0x0, 0xcf, 0xc0, 0x0, 0x0, 0xa, + 0xfe, 0x10, 0x3, 0xff, 0x70, 0x0, 0x0, 0x1f, + 0xfb, 0x0, 0xa, 0xff, 0x30, 0x0, 0x0, 0x8f, + 0xf6, 0x0, 0x1f, 0xfd, 0x0, 0x0, 0x0, 0xef, + 0xf2, 0x0, 0x7f, 0xf9, 0x0, 0x0, 0x5, 0xff, + 0xc0, 0x0, 0xef, 0xf4, 0x0, 0x0, 0xc, 0xff, + 0x70, 0x5, 0xff, 0xe1, 0x0, 0x0, 0x5f, 0xfe, + 0x0, 0xe, 0xff, 0x70, 0x0, 0xd, 0xff, 0x50, + 0x6, 0xff, 0xd0, 0x0, 0x6, 0xff, 0xa0, 0x0, + 0xef, 0xf3, 0x0, 0x1, 0xef, 0xe1, 0x0, 0x8f, + 0xf7, 0x0, 0x0, 0x9f, 0xf4, 0x0, 0x2f, 0xfc, + 0x0, 0x0, 0x2f, 0xf9, 0x0, 0xb, 0xff, 0x20, + 0x0, 0xb, 0xfd, 0x0, 0x4, 0xff, 0x60, 0x0, + 0x5, 0xff, 0x30, 0x0, 0xdf, 0xa0, 0x0, 0x0, + + /* U+00BD "½" */ + 0x0, 0x0, 0x5f, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xf5, 0x0, 0x0, 0x0, 0x6f, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xf9, 0x0, 0x0, 0x1, 0xaf, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xfd, 0x0, 0x0, + 0x2, 0xff, 0xec, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0x30, 0x0, 0x0, 0x3f, 0x91, + 0x8f, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x8, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xe0, + 0x0, 0x0, 0x0, 0x1e, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xfe, 0x0, 0x0, 0x0, + 0xb, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xe0, 0x0, 0x0, 0x7, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xfe, + 0x0, 0x0, 0x3, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x49, 0x80, 0x0, 0x0, + 0xdf, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xe1, 0x0, + 0x2, 0x9d, 0xff, 0xd9, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xf4, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xf8, 0x0, 0x0, 0xdf, 0xe3, 0x1, 0x8f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xfd, 0x0, 0x0, + 0x19, 0xa5, 0x0, 0x0, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xf6, 0x0, 0x0, 0x0, 0x3, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3e, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xfc, 0x10, 0x0, 0x0, + 0x0, 0xaf, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xbf, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xef, 0xe5, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xef, 0xc1, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xff, 0xff, 0xff, 0xfc, 0x0, 0x8, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x78, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0384 "΄" */ + 0x0, 0x2a, 0xaa, 0x50, 0xa, 0xff, 0xd0, 0x2, + 0xff, 0xf2, 0x0, 0x9f, 0xf5, 0x0, 0x1f, 0xf8, + 0x0, 0x0, + + /* U+0386 "Ά" */ + 0x0, 0x2, 0xff, 0xf9, 0x0, 0xdf, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xc0, + 0x4, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xfe, 0x20, 0xa, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x0, + 0x1f, 0xfc, 0xbf, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9a, 0x60, 0x0, 0x6f, 0xf8, 0x6f, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xf3, 0xf, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xd0, 0xa, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0x80, 0x4, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x10, 0x0, 0xdf, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xfb, 0x0, 0x0, 0x7f, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xf5, 0x0, 0x0, 0x1f, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xe0, 0x0, 0x0, 0xb, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0x90, 0x0, 0x0, 0x5, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0x30, 0x0, 0x0, 0x0, 0xef, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x1, 0xff, 0xfa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xae, 0xff, 0xa0, 0x0, 0x0, 0x7, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf1, 0x0, + 0x0, 0xd, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xf7, 0x0, 0x0, 0x4f, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfe, 0x0, + 0x0, 0xaf, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x40, 0x1, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xb0, + 0x6, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf2, 0xd, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf8, + + /* U+0388 "Έ" */ + 0x0, 0x8f, 0xff, 0x40, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, 0xe, 0xff, + 0x70, 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf4, 0x7, 0xff, 0xa0, 0x0, 0x5f, + 0xff, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, + 0x30, 0xef, 0xd0, 0x0, 0x5, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3a, 0xa2, + 0x0, 0x0, 0x5f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xd4, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xfd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdb, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, + + /* U+0389 "Ή" */ + 0x0, 0x7f, 0xff, 0x40, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf1, 0x0, 0xef, + 0xf7, 0x0, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xf1, 0x7, 0xff, 0xb0, 0x0, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf1, 0xe, 0xfd, 0x0, 0x0, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf1, + 0x3a, 0xa2, 0x0, 0x0, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xfe, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xde, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf1, + + /* U+038A "Ί" */ + 0x0, 0x7f, 0xff, 0x40, 0xff, 0xf3, 0x0, 0xef, + 0xf7, 0x0, 0xff, 0xf3, 0x7, 0xff, 0xb0, 0x0, + 0xff, 0xf3, 0xe, 0xfd, 0x0, 0x0, 0xff, 0xf3, + 0x3a, 0xa2, 0x0, 0x0, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf3, + + /* U+038C "Ό" */ + 0x0, 0x8f, 0xff, 0x40, 0x0, 0x27, 0xbd, 0xff, + 0xec, 0x83, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0x70, 0x2, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x40, 0x0, 0x0, 0x7, 0xff, 0xa0, 0x5, 0xff, + 0xff, 0xfe, 0xdc, 0xef, 0xff, 0xff, 0x80, 0x0, + 0x0, 0xef, 0xd0, 0x7, 0xff, 0xff, 0x82, 0x0, + 0x0, 0x17, 0xef, 0xff, 0x90, 0x0, 0x3a, 0xa2, + 0x4, 0xff, 0xfc, 0x10, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x60, 0x0, 0x0, 0x0, 0xef, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x10, 0x0, 0x0, 0x6f, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xf9, 0x0, 0x0, + 0xc, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf0, 0x0, 0x1, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x40, 0x0, 0x4f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf8, 0x0, + 0x6, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0x90, 0x0, 0x7f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xfb, 0x0, 0x8, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xb0, + 0x0, 0x7f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xf9, 0x0, 0x5, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x80, 0x0, 0x1f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf4, + 0x0, 0x0, 0xcf, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0x0, 0x0, 0x6, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0x90, 0x0, 0x0, 0xe, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xc1, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xf7, 0x20, 0x0, 0x1, 0x6e, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xed, 0xce, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2b, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0x7b, 0xef, 0xfe, 0xc8, + 0x30, 0x0, 0x0, 0x0, + + /* U+038E "Ύ" */ + 0x0, 0x8f, 0xff, 0x40, 0x5f, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x40, + 0xe, 0xff, 0x70, 0x0, 0xaf, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x90, 0x7, + 0xff, 0xa0, 0x0, 0x1, 0xef, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xd0, 0x0, 0xef, + 0xd0, 0x0, 0x0, 0x5, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf3, 0x0, 0x3a, 0xa2, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0xcf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x80, 0x0, 0x0, + 0x7f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0x30, 0x0, 0x2f, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xfc, 0x0, 0xc, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xf6, 0x6, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xe2, 0xef, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xef, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+038F "Ώ" */ + 0x0, 0x8f, 0xff, 0x40, 0x0, 0x38, 0xce, 0xff, + 0xec, 0x82, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf7, + 0x0, 0x2b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa1, + 0x0, 0x0, 0x7, 0xff, 0xa0, 0x4, 0xff, 0xff, + 0xfe, 0xcc, 0xef, 0xff, 0xfe, 0x20, 0x0, 0xe, + 0xfd, 0x0, 0x4f, 0xff, 0xf9, 0x20, 0x0, 0x3, + 0xbf, 0xff, 0xe2, 0x0, 0x3a, 0xa2, 0x1, 0xef, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0x60, 0x0, 0x0, + 0x1f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xd0, 0x0, 0x0, 0x6f, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf3, + 0x0, 0x0, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xf7, 0x0, 0x0, 0xdf, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xf9, 0x0, 0x0, 0xef, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfa, 0x0, + 0x0, 0xef, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xfb, 0x0, 0x0, 0xdf, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xfa, 0x0, 0x0, 0xbf, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf7, 0x0, 0x0, + 0x7f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xf4, 0x0, 0x0, 0x2f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xe0, + 0x0, 0x0, 0xb, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0x70, 0x0, 0x0, 0x3, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0x70, 0x0, 0x0, 0x0, + 0xa, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xfb, 0x10, 0x0, 0x3, 0xcf, 0xf6, 0x0, + 0x0, 0x0, 0x3, 0xdd, 0xdd, 0xdf, 0xff, 0xf2, + 0x0, 0x5f, 0xff, 0xfd, 0xdd, 0xdd, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0x0, 0x3, 0xff, 0xff, 0xff, + 0xff, 0xf4, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, + + /* U+0390 "ΐ" */ + 0x0, 0x0, 0x0, 0x5f, 0xf9, 0x0, 0x0, 0x22, + 0x10, 0xc, 0xfe, 0x12, 0x22, 0x4f, 0xf9, 0x3, + 0xff, 0x41, 0xff, 0xd4, 0xff, 0x90, 0xaf, 0xa0, + 0x1f, 0xfd, 0x4f, 0xf9, 0x1f, 0xe1, 0x1, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0x40, 0x0, 0x0, + + /* U+0391 "Α" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xfb, 0xbf, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf7, 0x5f, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xf2, 0xf, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xd0, 0xa, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0x70, 0x4, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x10, 0x0, 0xdf, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xfb, 0x0, 0x0, 0x7f, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xf5, 0x0, 0x0, 0x1f, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xe0, 0x0, 0x0, 0xb, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0x90, 0x0, 0x0, 0x5, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0x30, 0x0, 0x0, 0x0, 0xef, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x1, 0xff, 0xfa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xae, 0xff, 0xa0, 0x0, 0x0, 0x7, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf1, 0x0, + 0x0, 0xd, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xf7, 0x0, 0x0, 0x4f, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfe, 0x0, + 0x0, 0xaf, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x40, 0x1, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xb0, + 0x6, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf2, 0xd, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf8, + + /* U+0392 "Β" */ + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xb6, 0x10, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x8f, 0xff, 0xee, 0xee, 0xee, + 0xff, 0xff, 0xff, 0x60, 0x8, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x15, 0xdf, 0xff, 0x10, 0x8f, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xf7, 0x8, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xa0, 0x8f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfa, 0x8, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0x70, 0x8f, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xf2, 0x8, 0xff, 0xb0, + 0x0, 0x0, 0x1, 0x37, 0xef, 0xf7, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x50, 0x0, 0x8f, 0xff, 0xee, 0xee, 0xee, 0xef, + 0xff, 0xff, 0xb0, 0x8, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x3, 0x9f, 0xff, 0xc0, 0x8f, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x58, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfb, + 0x8f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xd8, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xfd, 0x8f, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xb8, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf7, 0x8f, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x28, 0xff, 0xfe, 0x18, + 0xff, 0xfd, 0xdd, 0xdd, 0xde, 0xff, 0xff, 0xff, + 0x40, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x40, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xec, 0x95, 0x0, 0x0, + + /* U+0393 "Γ" */ + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x4f, 0xff, 0xee, 0xee, 0xee, 0xee, 0xee, 0xed, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0394 "Δ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xfb, 0xbf, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf7, 0x6f, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xf2, 0x1f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xd0, 0xa, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0x80, 0x4, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x20, 0x0, 0xef, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xfc, 0x0, 0x0, 0x8f, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xf6, 0x0, 0x0, 0x2f, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xf0, 0x0, 0x0, 0xc, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xa0, 0x0, 0x0, 0x5, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0x40, 0x0, 0x0, 0x0, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x30, 0x0, + 0x0, 0x1, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xa0, 0x0, 0x0, 0x8, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf1, 0x0, + 0x0, 0xe, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xf7, 0x0, 0x0, 0x4f, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfd, 0x0, + 0x0, 0xaf, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x40, 0x1, 0xff, 0xfe, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdf, 0xff, 0xb0, + 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf2, 0xd, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + + /* U+0395 "Ε" */ + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x45, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf4, 0x5f, 0xff, 0xee, 0xee, 0xee, + 0xee, 0xee, 0xee, 0xee, 0x35, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, + 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x60, 0x5f, 0xff, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xd5, 0x5, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xfd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdb, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd5, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, + + /* U+0396 "Ζ" */ + 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf7, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf7, 0x0, 0xde, 0xee, 0xee, + 0xee, 0xee, 0xee, 0xee, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xed, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdb, 0x6f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x6f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + + /* U+0397 "Η" */ + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfd, 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfd, 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfd, 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x4f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x4f, 0xff, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xef, 0xfd, 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfd, 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfd, 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, + + /* U+0398 "Θ" */ + 0x0, 0x0, 0x0, 0x2, 0x6b, 0xde, 0xfe, 0xc9, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x4e, 0xff, 0xff, 0xed, 0xce, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0x93, 0x0, 0x0, 0x16, 0xdf, 0xff, 0xb0, 0x0, + 0x0, 0x2f, 0xff, 0xd2, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf9, 0x0, 0x0, 0xcf, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x30, + 0x4, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xb0, 0xa, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf2, + 0xe, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf6, 0x2f, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfa, + 0x4f, 0xff, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x9f, 0xfc, 0x5f, 0xff, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x7f, 0xfd, + 0x6f, 0xff, 0x0, 0x7, 0xdd, 0xdd, 0xdd, 0xdd, + 0xd0, 0x0, 0x7f, 0xfd, 0x5f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfc, + 0x3f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xfa, 0xf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf6, + 0xa, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf2, 0x4, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xb0, + 0x0, 0xcf, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0x30, 0x0, 0x2f, 0xff, 0xd2, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf9, 0x0, + 0x0, 0x5, 0xff, 0xff, 0x82, 0x0, 0x0, 0x16, + 0xdf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x4e, 0xff, + 0xff, 0xed, 0xce, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x7b, 0xef, 0xfe, 0xc9, 0x40, 0x0, 0x0, 0x0, + + /* U+0399 "Ι" */ + 0xef, 0xf5, 0xef, 0xf5, 0xef, 0xf5, 0xef, 0xf5, + 0xef, 0xf5, 0xef, 0xf5, 0xef, 0xf5, 0xef, 0xf5, + 0xef, 0xf5, 0xef, 0xf5, 0xef, 0xf5, 0xef, 0xf5, + 0xef, 0xf5, 0xef, 0xf5, 0xef, 0xf5, 0xef, 0xf5, + 0xef, 0xf5, 0xef, 0xf5, 0xef, 0xf5, 0xef, 0xf5, + 0xef, 0xf5, 0xef, 0xf5, 0xef, 0xf5, 0xef, 0xf5, + + /* U+039A "Κ" */ + 0x8f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfa, 0x8, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf9, 0x0, 0x8f, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xf8, 0x0, 0x8, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf8, + 0x0, 0x0, 0x8f, 0xfb, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xf7, 0x0, 0x0, 0x8, 0xff, 0xb0, 0x0, + 0x0, 0xb, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x8f, + 0xfb, 0x0, 0x0, 0xb, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xb0, 0x0, 0xc, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfb, 0x0, 0xc, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xb0, 0xc, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xfb, 0xc, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xcc, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xe2, 0xcf, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xe2, 0x2, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xd1, 0x0, 0x6, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x8, 0xff, 0xe1, + 0x0, 0x0, 0xa, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x8f, 0xfb, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xe1, + 0x0, 0x0, 0x8, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xc0, 0x0, 0x0, 0x8f, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0x80, 0x0, 0x8, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x40, 0x0, 0x8f, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xfe, 0x10, 0x8, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xfb, 0x0, 0x8f, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf8, 0x8, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xf4, + + /* U+039B "Λ" */ + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0x7f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xb1, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf6, 0xc, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x10, 0x6f, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xb0, 0x1, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xf5, 0x0, 0xa, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xfe, 0x0, 0x0, 0x5f, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x90, + 0x0, 0x0, 0xef, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xf3, 0x0, 0x0, 0x9, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xfc, 0x0, 0x0, + 0x0, 0x3f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0x60, 0x0, 0x0, 0x0, 0xdf, 0xf5, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x7f, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x10, 0x0, + 0x0, 0xd, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xf8, 0x0, 0x0, 0x3, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xe0, 0x0, 0x0, + 0xaf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x40, 0x0, 0x1f, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xfa, 0x0, 0x6, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xf1, 0x0, 0xdf, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0x70, 0x3f, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfd, + 0x9, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf4, + + /* U+039C "Μ" */ + 0x7f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xfc, 0x7f, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfc, + 0x7f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xfc, 0x7f, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfc, + 0x7f, 0xfb, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xcf, 0xfc, 0x7f, 0xfa, 0xaf, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x7f, 0xfc, + 0x7f, 0xfa, 0x5f, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xfc, 0x5f, 0xfc, 0x7f, 0xfa, 0xf, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xf6, 0x5f, 0xfc, + 0x7f, 0xfa, 0xa, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x8f, 0xf1, 0x5f, 0xfc, 0x7f, 0xfa, 0x4, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0xdf, 0xb0, 0x5f, 0xfc, + 0x7f, 0xfa, 0x0, 0xef, 0xf0, 0x0, 0x0, 0x3, + 0xff, 0x50, 0x5f, 0xfc, 0x7f, 0xfa, 0x0, 0x9f, + 0xf4, 0x0, 0x0, 0x8, 0xff, 0x0, 0x5f, 0xfc, + 0x7f, 0xfa, 0x0, 0x4f, 0xfa, 0x0, 0x0, 0xe, + 0xfa, 0x0, 0x5f, 0xfc, 0x7f, 0xfa, 0x0, 0xe, + 0xff, 0x0, 0x0, 0x4f, 0xf4, 0x0, 0x5f, 0xfc, + 0x7f, 0xfa, 0x0, 0x9, 0xff, 0x50, 0x0, 0x9f, + 0xe0, 0x0, 0x5f, 0xfc, 0x7f, 0xfa, 0x0, 0x3, + 0xff, 0xa0, 0x0, 0xef, 0x90, 0x0, 0x5f, 0xfc, + 0x7f, 0xfa, 0x0, 0x0, 0xef, 0xf0, 0x4, 0xff, + 0x30, 0x0, 0x5f, 0xfc, 0x7f, 0xfa, 0x0, 0x0, + 0x8f, 0xf5, 0xa, 0xfe, 0x0, 0x0, 0x5f, 0xfc, + 0x7f, 0xfa, 0x0, 0x0, 0x3f, 0xfa, 0xf, 0xf8, + 0x0, 0x0, 0x5f, 0xfc, 0x7f, 0xfa, 0x0, 0x0, + 0xd, 0xff, 0x5f, 0xf3, 0x0, 0x0, 0x5f, 0xfc, + 0x7f, 0xfa, 0x0, 0x0, 0x8, 0xff, 0xef, 0xd0, + 0x0, 0x0, 0x5f, 0xfc, 0x7f, 0xfa, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x70, 0x0, 0x0, 0x5f, 0xfc, + 0x7f, 0xfa, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x20, + 0x0, 0x0, 0x5f, 0xfc, 0x7f, 0xfa, 0x0, 0x0, + 0x0, 0x7f, 0xfc, 0x0, 0x0, 0x0, 0x5f, 0xfc, + + /* U+039D "Ν" */ + 0x5f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xfd, 0x5f, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xfd, 0x5f, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfd, 0x5f, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfd, + 0x5f, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xfd, 0x5f, 0xfd, 0xef, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xfd, 0x5f, 0xfc, 0x4f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x3f, 0xfd, 0x5f, 0xfc, + 0x9, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x3f, 0xfd, + 0x5f, 0xfc, 0x0, 0xef, 0xfc, 0x0, 0x0, 0x0, + 0x3f, 0xfd, 0x5f, 0xfc, 0x0, 0x4f, 0xff, 0x70, + 0x0, 0x0, 0x3f, 0xfd, 0x5f, 0xfc, 0x0, 0x9, + 0xff, 0xf2, 0x0, 0x0, 0x3f, 0xfd, 0x5f, 0xfc, + 0x0, 0x0, 0xdf, 0xfc, 0x0, 0x0, 0x3f, 0xfd, + 0x5f, 0xfc, 0x0, 0x0, 0x3f, 0xff, 0x70, 0x0, + 0x3f, 0xfd, 0x5f, 0xfc, 0x0, 0x0, 0x8, 0xff, + 0xf2, 0x0, 0x3f, 0xfd, 0x5f, 0xfc, 0x0, 0x0, + 0x0, 0xdf, 0xfc, 0x0, 0x3f, 0xfd, 0x5f, 0xfc, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x80, 0x3f, 0xfd, + 0x5f, 0xfc, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf3, + 0x3f, 0xfd, 0x5f, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xfd, 0x4f, 0xfd, 0x5f, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xcf, 0xfd, 0x5f, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xfd, + 0x5f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xfd, 0x5f, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xfd, 0x5f, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xfd, 0x5f, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfd, + + /* U+039E "Ξ" */ + 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd0, 0xa, 0xee, 0xee, 0xee, + 0xee, 0xee, 0xee, 0xee, 0xee, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2d, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xd3, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2d, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xd3, 0x3f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + + /* U+039F "Ο" */ + 0x0, 0x0, 0x0, 0x2, 0x6b, 0xde, 0xfe, 0xc9, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x4e, 0xff, 0xff, 0xed, 0xce, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0x93, 0x0, 0x0, 0x16, 0xdf, 0xff, 0xb0, 0x0, + 0x0, 0x2f, 0xff, 0xd2, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf9, 0x0, 0x0, 0xcf, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x30, + 0x4, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xb0, 0xa, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf2, + 0xe, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf6, 0x2f, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfa, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xfc, 0x5f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfd, + 0x6f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xfd, 0x5f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfc, + 0x3f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xfa, 0xf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf6, + 0xa, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf2, 0x4, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xb0, + 0x0, 0xcf, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0x30, 0x0, 0x2f, 0xff, 0xd2, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf9, 0x0, + 0x0, 0x5, 0xff, 0xff, 0x82, 0x0, 0x0, 0x16, + 0xdf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x4e, 0xff, + 0xff, 0xed, 0xce, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x7b, 0xef, 0xfe, 0xc9, 0x40, 0x0, 0x0, 0x0, + + /* U+03A0 "Π" */ + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x4f, 0xff, 0xee, 0xee, + 0xee, 0xee, 0xee, 0xee, 0xef, 0xfd, 0x4f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfd, 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfd, 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfd, 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfd, 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfd, 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, 0x4f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, + + /* U+03A1 "Ρ" */ + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdb, 0x83, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x6f, 0xff, 0xee, 0xee, + 0xee, 0xee, 0xff, 0xff, 0xfb, 0x0, 0x6f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xcf, 0xff, 0x60, + 0x6f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xd0, 0x6f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xf1, 0x6f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf2, 0x6f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf2, + 0x6f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf0, 0x6f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xb0, 0x6f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x16, 0xef, 0xff, 0x30, 0x6f, 0xff, + 0xee, 0xee, 0xee, 0xef, 0xff, 0xff, 0xf8, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0xda, 0x61, 0x0, 0x0, 0x6f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A3 "Σ" */ + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf0, 0x8f, 0xff, 0xee, 0xee, 0xee, 0xee, + 0xee, 0xee, 0xe0, 0x4f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2e, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xdf, 0xfd, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xe2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xd9, 0x8f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, + + /* U+03A4 "Τ" */ + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x4, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf0, 0x3e, 0xee, 0xee, + 0xee, 0xef, 0xff, 0xee, 0xee, 0xee, 0xee, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, + + /* U+03A5 "Υ" */ + 0x9f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0x10, 0xdf, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x50, 0x3, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xa0, 0x0, 0x8, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xe1, 0x0, 0x0, 0xd, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xa0, 0x0, 0x0, + 0x1, 0xef, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x50, 0x0, 0x0, 0xaf, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xfe, 0x10, 0x0, 0x5f, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xf9, 0x0, 0x1e, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf3, 0x9, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xd3, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+03A6 "Φ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xee, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x47, 0x9a, 0xff, 0xfb, 0x97, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x20, 0x0, 0x0, 0x0, + 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x3f, 0xff, 0xfa, 0x51, + 0x1f, 0xff, 0x31, 0x49, 0xff, 0xff, 0x50, 0x0, + 0xe, 0xff, 0xd3, 0x0, 0x0, 0xff, 0xf2, 0x0, + 0x2, 0xdf, 0xff, 0x20, 0x8, 0xff, 0xf2, 0x0, + 0x0, 0xf, 0xff, 0x20, 0x0, 0x1, 0xef, 0xfb, + 0x0, 0xef, 0xf7, 0x0, 0x0, 0x0, 0xff, 0xf2, + 0x0, 0x0, 0x6, 0xff, 0xf2, 0x4f, 0xff, 0x10, + 0x0, 0x0, 0xf, 0xff, 0x20, 0x0, 0x0, 0xf, + 0xff, 0x67, 0xff, 0xe0, 0x0, 0x0, 0x0, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0xbf, 0xf9, 0x8f, 0xfc, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x20, 0x0, 0x0, + 0x9, 0xff, 0xa8, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x9f, 0xfa, 0x7f, + 0xfe, 0x0, 0x0, 0x0, 0xf, 0xff, 0x20, 0x0, + 0x0, 0xb, 0xff, 0x94, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0xff, 0xf2, 0x0, 0x0, 0x0, 0xef, 0xf6, + 0xf, 0xff, 0x80, 0x0, 0x0, 0xf, 0xff, 0x20, + 0x0, 0x0, 0x5f, 0xff, 0x10, 0x8f, 0xff, 0x30, + 0x0, 0x0, 0xff, 0xf2, 0x0, 0x0, 0x1d, 0xff, + 0xa0, 0x1, 0xef, 0xfe, 0x40, 0x0, 0xf, 0xff, + 0x20, 0x0, 0x2c, 0xff, 0xf2, 0x0, 0x3, 0xff, + 0xff, 0xb5, 0x21, 0xff, 0xf3, 0x14, 0x9f, 0xff, + 0xf4, 0x0, 0x0, 0x2, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe4, 0x0, 0x0, 0x0, + 0x0, 0x7e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x81, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x79, + 0xaf, 0xff, 0xb9, 0x73, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A7 "Χ" */ + 0x6, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf6, 0x0, 0xa, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfa, 0x0, 0x0, + 0xd, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xfd, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x50, 0x0, 0x0, 0x3f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfe, 0x10, 0x0, + 0x1d, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xfb, 0x0, 0xb, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf7, 0x7, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xf4, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1d, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xd4, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xf3, 0x9, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf7, 0x0, 0xd, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xfc, + 0x0, 0x0, 0x3f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xfe, 0x10, 0x0, 0x0, 0x7f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x30, 0x0, 0x0, 0x3f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x1, 0xef, 0xfd, + 0x0, 0x0, 0x1e, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xfa, 0x0, 0xb, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf6, + 0x7, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf2, + + /* U+03A8 "Ψ" */ + 0xef, 0xf5, 0x0, 0x0, 0x0, 0x6f, 0xfd, 0x0, + 0x0, 0x0, 0xf, 0xff, 0x4e, 0xff, 0x50, 0x0, + 0x0, 0x6, 0xff, 0xd0, 0x0, 0x0, 0x0, 0xff, + 0xf4, 0xef, 0xf5, 0x0, 0x0, 0x0, 0x6f, 0xfd, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x4e, 0xff, 0x50, + 0x0, 0x0, 0x6, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0xff, 0xf4, 0xef, 0xf5, 0x0, 0x0, 0x0, 0x6f, + 0xfd, 0x0, 0x0, 0x0, 0xf, 0xff, 0x4e, 0xff, + 0x50, 0x0, 0x0, 0x6, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0xff, 0xf4, 0xef, 0xf5, 0x0, 0x0, 0x0, + 0x6f, 0xfd, 0x0, 0x0, 0x0, 0xf, 0xff, 0x4d, + 0xff, 0x60, 0x0, 0x0, 0x6, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0xff, 0xf4, 0xcf, 0xf7, 0x0, 0x0, + 0x0, 0x6f, 0xfd, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0x2a, 0xff, 0xa0, 0x0, 0x0, 0x6, 0xff, 0xd0, + 0x0, 0x0, 0x5, 0xff, 0xf1, 0x6f, 0xff, 0x0, + 0x0, 0x0, 0x6f, 0xfd, 0x0, 0x0, 0x0, 0xaf, + 0xfd, 0x1, 0xff, 0xf8, 0x0, 0x0, 0x6, 0xff, + 0xd0, 0x0, 0x0, 0x3f, 0xff, 0x80, 0x9, 0xff, + 0xf8, 0x0, 0x0, 0x6f, 0xfd, 0x0, 0x0, 0x4e, + 0xff, 0xf1, 0x0, 0x1d, 0xff, 0xfe, 0x73, 0x6, + 0xff, 0xd0, 0x25, 0xbf, 0xff, 0xf5, 0x0, 0x0, + 0x2d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x8, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xa2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x47, 0xab, 0xdf, 0xff, 0xba, + 0x85, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+03A9 "Ω" */ + 0x0, 0x0, 0x0, 0x4, 0x9c, 0xef, 0xfe, 0xb7, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3c, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xec, 0xdf, 0xff, 0xff, + 0xd1, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf8, 0x10, + 0x0, 0x4, 0xcf, 0xff, 0xd0, 0x0, 0x0, 0x3f, + 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xa0, 0x0, 0xc, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x30, 0x4, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xfb, + 0x0, 0x9f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xf1, 0xd, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x40, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf7, 0x1f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0x81, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xf8, 0xf, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0x70, 0xef, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xf5, 0xa, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0x10, 0x5f, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xc0, + 0x0, 0xef, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xf5, 0x0, 0x5, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xfc, 0x0, 0x0, + 0xa, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0x20, 0x0, 0x0, 0xc, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x1c, 0xff, 0x40, 0x0, 0x0, 0x0, + 0xb, 0xff, 0x91, 0x0, 0x0, 0x4e, 0xff, 0x40, + 0x0, 0x5, 0xdd, 0xdd, 0xef, 0xff, 0xe1, 0x0, + 0x8f, 0xff, 0xfd, 0xdd, 0xdb, 0x6f, 0xff, 0xff, + 0xff, 0xff, 0x10, 0xa, 0xff, 0xff, 0xff, 0xff, + 0xd6, 0xff, 0xff, 0xff, 0xff, 0xf1, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xfd, + + /* U+03AA "Ϊ" */ + 0xf, 0xff, 0x10, 0xd, 0xff, 0x40, 0xff, 0xf1, + 0x0, 0xdf, 0xf4, 0xf, 0xff, 0x10, 0xd, 0xff, + 0x40, 0x66, 0x60, 0x0, 0x56, 0x61, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0x50, + 0x0, 0x0, 0x0, 0xef, 0xf5, 0x0, 0x0, 0x0, + 0xe, 0xff, 0x50, 0x0, 0x0, 0x0, 0xef, 0xf5, + 0x0, 0x0, 0x0, 0xe, 0xff, 0x50, 0x0, 0x0, + 0x0, 0xef, 0xf5, 0x0, 0x0, 0x0, 0xe, 0xff, + 0x50, 0x0, 0x0, 0x0, 0xef, 0xf5, 0x0, 0x0, + 0x0, 0xe, 0xff, 0x50, 0x0, 0x0, 0x0, 0xef, + 0xf5, 0x0, 0x0, 0x0, 0xe, 0xff, 0x50, 0x0, + 0x0, 0x0, 0xef, 0xf5, 0x0, 0x0, 0x0, 0xe, + 0xff, 0x50, 0x0, 0x0, 0x0, 0xef, 0xf5, 0x0, + 0x0, 0x0, 0xe, 0xff, 0x50, 0x0, 0x0, 0x0, + 0xef, 0xf5, 0x0, 0x0, 0x0, 0xe, 0xff, 0x50, + 0x0, 0x0, 0x0, 0xef, 0xf5, 0x0, 0x0, 0x0, + 0xe, 0xff, 0x50, 0x0, 0x0, 0x0, 0xef, 0xf5, + 0x0, 0x0, 0x0, 0xe, 0xff, 0x50, 0x0, 0x0, + 0x0, 0xef, 0xf5, 0x0, 0x0, 0x0, 0xe, 0xff, + 0x50, 0x0, 0x0, 0x0, 0xef, 0xf5, 0x0, 0x0, + + /* U+03AB "Ϋ" */ + 0x0, 0x0, 0x0, 0x6f, 0xfb, 0x0, 0x3f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xb0, 0x3, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xfb, 0x0, 0x3f, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x66, 0x40, + 0x1, 0x66, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xf1, 0xd, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf5, + 0x0, 0x3f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xfa, 0x0, 0x0, 0x8f, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfe, 0x10, 0x0, + 0x0, 0xdf, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0x40, 0x0, 0x0, 0x3, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xf5, 0x0, 0x0, 0xa, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xe1, 0x0, + 0x5, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x90, 0x1, 0xef, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x30, 0x9f, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xfd, 0x3f, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03AC "ά" */ + 0x0, 0x0, 0x0, 0x0, 0x2a, 0xaa, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfd, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5b, 0xef, 0xec, 0x60, 0x0, 0xdf, + 0xf3, 0x0, 0x1c, 0xff, 0xff, 0xff, 0xfb, 0x11, + 0xff, 0xe0, 0x0, 0xdf, 0xff, 0xc8, 0x8b, 0xff, + 0xb5, 0xff, 0xa0, 0x8, 0xff, 0xf6, 0x0, 0x0, + 0x3e, 0xfe, 0xff, 0x60, 0xf, 0xff, 0x80, 0x0, + 0x0, 0x4, 0xff, 0xff, 0x20, 0x5f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0x0, 0x9f, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfb, 0x0, 0xbf, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf8, 0x0, + 0xcf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf5, + 0x0, 0xcf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xf5, 0x0, 0xbf, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xf8, 0x0, 0x8f, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xfb, 0x0, 0x5f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xfe, 0x0, 0xe, 0xff, 0x80, + 0x0, 0x0, 0x6, 0xff, 0xff, 0x10, 0x7, 0xff, + 0xf5, 0x0, 0x0, 0x5f, 0xfd, 0xff, 0x50, 0x0, + 0xcf, 0xff, 0xb8, 0x8c, 0xff, 0xb6, 0xff, 0x90, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xfc, 0x11, 0xff, + 0xd0, 0x0, 0x0, 0x5b, 0xef, 0xec, 0x60, 0x0, + 0xcf, 0xf3, + + /* U+03AD "έ" */ + 0x0, 0x0, 0x0, 0x1a, 0xaa, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xfe, 0x20, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0xe, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xad, 0xff, 0xd9, 0x30, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x2, 0xff, + 0xfd, 0xaa, 0xef, 0xff, 0x60, 0xa, 0xff, 0x90, + 0x0, 0x5, 0xd5, 0x0, 0xd, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xdf, 0xfe, 0xa8, 0x50, 0x0, 0x0, + 0x0, 0x1c, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xc0, 0x0, 0x0, 0xb, 0xff, + 0xe6, 0x20, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xfd, 0x0, 0x0, 0x0, + 0x4, 0x0, 0x1f, 0xff, 0x70, 0x0, 0x3, 0xdf, + 0x80, 0x9, 0xff, 0xfc, 0x88, 0xcf, 0xff, 0xd1, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xfb, 0x10, 0x0, + 0x5, 0xbe, 0xfe, 0xd9, 0x30, 0x0, + + /* U+03AE "ή" */ + 0x0, 0x0, 0x0, 0x4, 0xaa, 0xa3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xfd, 0x10, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0x0, 0x4a, + 0xef, 0xeb, 0x50, 0x0, 0xbf, 0xf0, 0xaf, 0xff, + 0xff, 0xff, 0xc1, 0xb, 0xff, 0xaf, 0xfd, 0xaa, + 0xdf, 0xff, 0xb0, 0xbf, 0xff, 0xe3, 0x0, 0x0, + 0x7f, 0xff, 0x3b, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0xdf, 0xf7, 0xbf, 0xfb, 0x0, 0x0, 0x0, 0x8, + 0xff, 0x9b, 0xff, 0x70, 0x0, 0x0, 0x0, 0x6f, + 0xf9, 0xbf, 0xf5, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xab, 0xff, 0x40, 0x0, 0x0, 0x0, 0x5f, 0xfa, + 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x5, 0xff, 0xab, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x5f, 0xfa, 0xbf, + 0xf4, 0x0, 0x0, 0x0, 0x5, 0xff, 0xab, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x5f, 0xfa, 0xbf, 0xf4, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xab, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x5f, 0xfa, 0xbf, 0xf4, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xab, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x5f, 0xfa, 0xbf, 0xf4, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfa, + + /* U+03AF "ί" */ + 0x0, 0x4f, 0xff, 0x80, 0xb, 0xff, 0xb0, 0x3, + 0xff, 0xd1, 0x0, 0xaf, 0xf2, 0x0, 0xa, 0xa5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xf4, 0x0, 0xb, 0xff, 0x40, 0x0, + 0xbf, 0xf4, 0x0, 0xb, 0xff, 0x40, 0x0, 0xbf, + 0xf4, 0x0, 0xb, 0xff, 0x40, 0x0, 0xbf, 0xf4, + 0x0, 0xb, 0xff, 0x40, 0x0, 0xbf, 0xf4, 0x0, + 0xb, 0xff, 0x40, 0x0, 0xbf, 0xf4, 0x0, 0xb, + 0xff, 0x40, 0x0, 0xbf, 0xf4, 0x0, 0xb, 0xff, + 0x40, 0x0, 0xbf, 0xf4, 0x0, 0xb, 0xff, 0x40, + 0x0, 0xbf, 0xf4, 0x0, 0xb, 0xff, 0x40, 0x0, + + /* U+03B0 "ΰ" */ + 0x0, 0x0, 0x0, 0x5, 0x88, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xc0, 0x0, 0x0, 0xb, + 0xff, 0x20, 0x8f, 0xf2, 0x8f, 0xf5, 0x0, 0xbf, + 0xf2, 0xe, 0xf5, 0x8, 0xff, 0x50, 0xb, 0xff, + 0x27, 0xfa, 0x0, 0x8f, 0xf5, 0x0, 0x12, 0x20, + 0x12, 0x0, 0x1, 0x22, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf4, 0x0, 0x0, + 0x0, 0x9, 0xff, 0x6b, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x9f, 0xf6, 0xbf, 0xf4, 0x0, 0x0, 0x0, + 0x9, 0xff, 0x6b, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x9f, 0xf6, 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x9, + 0xff, 0x6b, 0xff, 0x40, 0x0, 0x0, 0x0, 0x9f, + 0xf6, 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x9, 0xff, + 0x6b, 0xff, 0x40, 0x0, 0x0, 0x0, 0x9f, 0xf6, + 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x9, 0xff, 0x6b, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x9f, 0xf6, 0xbf, + 0xf4, 0x0, 0x0, 0x0, 0xa, 0xff, 0x5b, 0xff, + 0x50, 0x0, 0x0, 0x0, 0xaf, 0xf4, 0x9f, 0xf7, + 0x0, 0x0, 0x0, 0xd, 0xff, 0x26, 0xff, 0xd0, + 0x0, 0x0, 0x3, 0xff, 0xe0, 0x1e, 0xff, 0xa0, + 0x0, 0x2, 0xef, 0xf8, 0x0, 0x5f, 0xff, 0xe8, + 0x7a, 0xff, 0xfd, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xff, 0xfc, 0x10, 0x0, 0x0, 0x28, 0xdf, 0xfe, + 0xb5, 0x0, 0x0, + + /* U+03B1 "α" */ + 0x0, 0x0, 0x5b, 0xef, 0xec, 0x60, 0x0, 0xdf, + 0xf3, 0x0, 0x1c, 0xff, 0xff, 0xff, 0xfb, 0x11, + 0xff, 0xe0, 0x0, 0xdf, 0xff, 0xc8, 0x8b, 0xff, + 0xb5, 0xff, 0xa0, 0x8, 0xff, 0xf6, 0x0, 0x0, + 0x3e, 0xfe, 0xff, 0x60, 0xf, 0xff, 0x80, 0x0, + 0x0, 0x4, 0xff, 0xff, 0x20, 0x5f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0x0, 0x9f, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfb, 0x0, 0xbf, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf8, 0x0, + 0xcf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf5, + 0x0, 0xcf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xf5, 0x0, 0xbf, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xf8, 0x0, 0x8f, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xfb, 0x0, 0x5f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xfe, 0x0, 0xe, 0xff, 0x80, + 0x0, 0x0, 0x6, 0xff, 0xff, 0x10, 0x7, 0xff, + 0xf5, 0x0, 0x0, 0x5f, 0xfd, 0xff, 0x50, 0x0, + 0xcf, 0xff, 0xb8, 0x8c, 0xff, 0xb6, 0xff, 0x90, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xfc, 0x11, 0xff, + 0xd0, 0x0, 0x0, 0x5b, 0xef, 0xec, 0x60, 0x0, + 0xcf, 0xf3, + + /* U+03B2 "β" */ + 0x0, 0x0, 0x5b, 0xef, 0xfd, 0x92, 0x0, 0x0, + 0x0, 0x3, 0xdf, 0xff, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x3, 0xff, 0xfe, 0x97, 0x8d, 0xff, 0xf5, + 0x0, 0x0, 0xdf, 0xf9, 0x0, 0x0, 0x7, 0xff, + 0xe0, 0x0, 0x3f, 0xfc, 0x0, 0x0, 0x0, 0xa, + 0xff, 0x50, 0x7, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x4f, 0xf8, 0x0, 0x9f, 0xf5, 0x0, 0x0, 0x0, + 0x4, 0xff, 0x70, 0xa, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x7f, 0xf4, 0x0, 0xaf, 0xf4, 0x0, 0x0, + 0x0, 0x2f, 0xfc, 0x0, 0xa, 0xff, 0x40, 0x0, + 0x14, 0x8f, 0xfd, 0x10, 0x0, 0xaf, 0xf4, 0x1, + 0xff, 0xff, 0xd7, 0x0, 0x0, 0xa, 0xff, 0x40, + 0x1f, 0xff, 0xff, 0xb6, 0x0, 0x0, 0xaf, 0xf4, + 0x0, 0x23, 0x58, 0xef, 0xfd, 0x10, 0xa, 0xff, + 0x40, 0x0, 0x0, 0x1, 0xbf, 0xfd, 0x0, 0xaf, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf7, 0xa, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x6, 0xff, 0xc0, + 0xaf, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xa, 0xff, 0x70, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xf0, 0xaf, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xfd, 0xa, 0xff, 0xf3, 0x0, 0x0, 0x0, 0xa, + 0xff, 0x90, 0xaf, 0xff, 0xe3, 0x0, 0x0, 0x5, + 0xff, 0xf2, 0xa, 0xff, 0xdf, 0xf9, 0x43, 0x4a, + 0xff, 0xf7, 0x0, 0xaf, 0xf4, 0x9f, 0xff, 0xff, + 0xff, 0xf7, 0x0, 0xa, 0xff, 0x40, 0x3a, 0xef, + 0xfd, 0x92, 0x0, 0x0, 0xaf, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03B3 "γ" */ + 0x6f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0x61, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf0, 0xa, 0xff, 0x60, 0x0, 0x0, 0x0, 0x5f, + 0xfa, 0x0, 0x5f, 0xfc, 0x0, 0x0, 0x0, 0xb, + 0xff, 0x40, 0x0, 0xef, 0xf1, 0x0, 0x0, 0x1, + 0xff, 0xe0, 0x0, 0x9, 0xff, 0x70, 0x0, 0x0, + 0x6f, 0xf9, 0x0, 0x0, 0x3f, 0xfc, 0x0, 0x0, + 0xc, 0xff, 0x30, 0x0, 0x0, 0xdf, 0xf2, 0x0, + 0x2, 0xff, 0xd0, 0x0, 0x0, 0x8, 0xff, 0x70, + 0x0, 0x7f, 0xf7, 0x0, 0x0, 0x0, 0x2f, 0xfd, + 0x0, 0xd, 0xff, 0x20, 0x0, 0x0, 0x0, 0xcf, + 0xf2, 0x3, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0x80, 0x8f, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xfd, 0xe, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xf7, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x0, 0x0, 0x0, 0x0, + + /* U+03B4 "δ" */ + 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x9f, 0xff, 0x86, 0x66, 0x66, 0x66, + 0x61, 0x0, 0x0, 0x4e, 0xfe, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1a, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xef, 0xa1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4a, 0xef, 0xff, + 0xe4, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xa5, + 0x45, 0xbf, 0xfb, 0x0, 0x0, 0x8f, 0xff, 0x40, + 0x0, 0x0, 0x5f, 0xfb, 0x0, 0xf, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x7f, 0xf8, 0x5, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xf1, 0x9f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0x6b, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, 0xcf, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xbc, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfb, + 0xaf, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xa7, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xf8, 0x3f, 0xff, 0x10, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x40, 0xcf, 0xfa, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xd0, 0x4, 0xff, 0xf9, 0x0, 0x0, 0x8, + 0xff, 0xf5, 0x0, 0x8, 0xff, 0xfe, 0x97, 0x9e, + 0xff, 0xf9, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x2, 0x8c, 0xef, + 0xec, 0x71, 0x0, 0x0, + + /* U+03B5 "ε" */ + 0x0, 0x3, 0xad, 0xff, 0xd9, 0x30, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x2, 0xff, + 0xfd, 0xaa, 0xef, 0xff, 0x60, 0xa, 0xff, 0x90, + 0x0, 0x5, 0xd5, 0x0, 0xd, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xdf, 0xfe, 0xa8, 0x50, 0x0, 0x0, + 0x0, 0x1c, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xc0, 0x0, 0x0, 0xb, 0xff, + 0xe6, 0x20, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xfd, 0x0, 0x0, 0x0, + 0x4, 0x0, 0x1f, 0xff, 0x70, 0x0, 0x3, 0xdf, + 0x80, 0x9, 0xff, 0xfc, 0x88, 0xcf, 0xff, 0xd1, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xfb, 0x10, 0x0, + 0x5, 0xbe, 0xfe, 0xd9, 0x30, 0x0, + + /* U+03B6 "ζ" */ + 0x0, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x6, + 0x66, 0x66, 0x6c, 0xff, 0xd3, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x1c, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x81, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xdb, 0x96, + 0x30, 0x0, 0x1, 0xcf, 0xff, 0xff, 0xff, 0xfb, + 0x10, 0x0, 0x7, 0xcf, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x16, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x4, + 0xef, 0xff, 0x60, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0xe, 0xda, 0x30, + 0x0, + + /* U+03B7 "η" */ + 0xbf, 0xf0, 0x4, 0xae, 0xfe, 0xb5, 0x0, 0xb, + 0xff, 0xa, 0xff, 0xff, 0xff, 0xfc, 0x10, 0xbf, + 0xfa, 0xff, 0xda, 0xad, 0xff, 0xfb, 0xb, 0xff, + 0xfe, 0x30, 0x0, 0x7, 0xff, 0xf3, 0xbf, 0xff, + 0x20, 0x0, 0x0, 0xd, 0xff, 0x7b, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x8f, 0xf9, 0xbf, 0xf7, 0x0, + 0x0, 0x0, 0x6, 0xff, 0x9b, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x5f, 0xfa, 0xbf, 0xf4, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xab, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x5f, 0xfa, 0xbf, 0xf4, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xab, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x5f, 0xfa, 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xab, 0xff, 0x40, 0x0, 0x0, 0x0, 0x5f, + 0xfa, 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xab, 0xff, 0x40, 0x0, 0x0, 0x0, 0x5f, 0xfa, + 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x5, 0xff, 0xab, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x5f, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xa0, + + /* U+03B8 "θ" */ + 0x0, 0x0, 0x6, 0xce, 0xfe, 0xb6, 0x0, 0x0, + 0x0, 0x0, 0x3d, 0xff, 0xff, 0xff, 0xfd, 0x20, + 0x0, 0x0, 0x2e, 0xff, 0xe9, 0x79, 0xef, 0xfe, + 0x10, 0x0, 0xb, 0xff, 0xa0, 0x0, 0x1, 0xbf, + 0xfa, 0x0, 0x3, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0xdf, 0xf2, 0x0, 0x9f, 0xf5, 0x0, 0x0, 0x0, + 0x6, 0xff, 0x80, 0xe, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xfd, 0x1, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xf0, 0x3f, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0x25, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xf4, 0x6f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x57, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x7f, 0xfc, + 0x66, 0x66, 0x66, 0x66, 0x6d, 0xff, 0x66, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf5, 0x5f, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x43, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf2, + 0x1f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0x0, 0xef, 0xf4, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xd0, 0x9, 0xff, 0x90, 0x0, 0x0, 0x0, 0xaf, + 0xf8, 0x0, 0x4f, 0xff, 0x20, 0x0, 0x0, 0x2f, + 0xff, 0x30, 0x0, 0xbf, 0xfc, 0x10, 0x0, 0x1d, + 0xff, 0xa0, 0x0, 0x2, 0xef, 0xfe, 0x97, 0x9f, + 0xff, 0xe1, 0x0, 0x0, 0x3, 0xdf, 0xff, 0xff, + 0xff, 0xd2, 0x0, 0x0, 0x0, 0x0, 0x6c, 0xef, + 0xeb, 0x60, 0x0, 0x0, + + /* U+03B9 "ι" */ + 0xbf, 0xf4, 0xbf, 0xf4, 0xbf, 0xf4, 0xbf, 0xf4, + 0xbf, 0xf4, 0xbf, 0xf4, 0xbf, 0xf4, 0xbf, 0xf4, + 0xbf, 0xf4, 0xbf, 0xf4, 0xbf, 0xf4, 0xbf, 0xf4, + 0xbf, 0xf4, 0xbf, 0xf4, 0xbf, 0xf4, 0xbf, 0xf4, + 0xbf, 0xf4, 0xbf, 0xf4, + + /* U+03BA "κ" */ + 0xcf, 0xf3, 0x0, 0x0, 0x3, 0xef, 0xfb, 0xc, + 0xff, 0x30, 0x0, 0x3, 0xff, 0xfa, 0x0, 0xcf, + 0xf3, 0x0, 0x3, 0xff, 0xfa, 0x0, 0xc, 0xff, + 0x30, 0x3, 0xff, 0xf9, 0x0, 0x0, 0xcf, 0xf3, + 0x3, 0xff, 0xf8, 0x0, 0x0, 0xc, 0xff, 0x34, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0xcf, 0xf7, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xfd, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0xcf, 0xf5, 0x1d, 0xff, 0xd0, + 0x0, 0x0, 0xc, 0xff, 0x30, 0x2f, 0xff, 0xb0, + 0x0, 0x0, 0xcf, 0xf3, 0x0, 0x4f, 0xff, 0x80, + 0x0, 0xc, 0xff, 0x30, 0x0, 0x7f, 0xff, 0x50, + 0x0, 0xcf, 0xf3, 0x0, 0x0, 0xaf, 0xff, 0x20, + 0xc, 0xff, 0x30, 0x0, 0x0, 0xdf, 0xfd, 0x10, + 0xcf, 0xf3, 0x0, 0x0, 0x2, 0xef, 0xfb, 0xc, + 0xff, 0x30, 0x0, 0x0, 0x4, 0xff, 0xf9, + + /* U+03BB "λ" */ + 0x0, 0x0, 0x8f, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xf8, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xfd, 0xe, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x9, 0xff, 0x70, 0x8f, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xf1, 0x2, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x5f, 0xfb, 0x0, 0xc, 0xff, 0x50, 0x0, + 0x0, 0xb, 0xff, 0x50, 0x0, 0x6f, 0xfb, 0x0, + 0x0, 0x1, 0xff, 0xf0, 0x0, 0x0, 0xff, 0xf1, + 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, 0xa, 0xff, + 0x70, 0x0, 0xd, 0xff, 0x30, 0x0, 0x0, 0x4f, + 0xfd, 0x0, 0x4, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0xef, 0xf3, 0x0, 0xaf, 0xf7, 0x0, 0x0, 0x0, + 0x8, 0xff, 0x90, 0xf, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0x6, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xf5, + + /* U+03BC "μ" */ + 0xaf, 0xf4, 0x0, 0x0, 0x0, 0x6, 0xff, 0x9a, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x6f, 0xf9, 0xaf, + 0xf4, 0x0, 0x0, 0x0, 0x6, 0xff, 0x9a, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x6f, 0xf9, 0xaf, 0xf4, + 0x0, 0x0, 0x0, 0x6, 0xff, 0x9a, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x6f, 0xf9, 0xaf, 0xf4, 0x0, + 0x0, 0x0, 0x6, 0xff, 0x9a, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x6f, 0xf9, 0xaf, 0xf4, 0x0, 0x0, + 0x0, 0x6, 0xff, 0x9a, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x6f, 0xf9, 0xaf, 0xf5, 0x0, 0x0, 0x0, + 0x7, 0xff, 0x9a, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x9f, 0xf9, 0xaf, 0xfa, 0x0, 0x0, 0x0, 0xc, + 0xff, 0x9a, 0xff, 0xf2, 0x0, 0x0, 0x4, 0xff, + 0xf9, 0xaf, 0xff, 0xd3, 0x0, 0x5, 0xff, 0xff, + 0x9a, 0xff, 0xff, 0xfd, 0xbe, 0xff, 0xef, 0xf9, + 0xaf, 0xf7, 0xff, 0xff, 0xff, 0xe4, 0xff, 0x9a, + 0xff, 0x41, 0x9e, 0xfe, 0x91, 0x1f, 0xf9, 0xaf, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+03BD "ν" */ + 0x6f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0x60, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf1, 0xa, 0xff, 0x70, 0x0, 0x0, 0x0, 0x5f, + 0xfa, 0x0, 0x4f, 0xfd, 0x0, 0x0, 0x0, 0xb, + 0xff, 0x40, 0x0, 0xef, 0xf2, 0x0, 0x0, 0x1, + 0xff, 0xe0, 0x0, 0x8, 0xff, 0x80, 0x0, 0x0, + 0x6f, 0xf9, 0x0, 0x0, 0x2f, 0xfd, 0x0, 0x0, + 0xc, 0xff, 0x30, 0x0, 0x0, 0xcf, 0xf3, 0x0, + 0x2, 0xff, 0xd0, 0x0, 0x0, 0x6, 0xff, 0x90, + 0x0, 0x8f, 0xf7, 0x0, 0x0, 0x0, 0xf, 0xfe, + 0x0, 0xd, 0xff, 0x10, 0x0, 0x0, 0x0, 0xaf, + 0xf4, 0x3, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0x90, 0x9f, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xfe, 0xe, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xf7, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xf1, 0x0, 0x0, + 0x0, + + /* U+03BE "ξ" */ + 0x0, 0x0, 0x39, 0xce, 0xff, 0xfd, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, 0xbf, + 0xff, 0xc9, 0x87, 0x76, 0x0, 0x4, 0xff, 0xd2, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xc1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xb8, 0x77, 0x74, 0x0, + 0x0, 0x7, 0xef, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x1b, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x3, + 0xef, 0xfc, 0x73, 0x10, 0x0, 0x0, 0x4f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf9, 0x30, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xca, + 0x60, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xfe, + 0x30, 0x0, 0x0, 0x27, 0xbe, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x15, 0xef, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xef, 0xf3, 0x0, 0x0, 0x0, 0x5, + 0xef, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0xe, 0xda, 0x40, + 0x0, + + /* U+03BF "ο" */ + 0x0, 0x0, 0x17, 0xce, 0xfe, 0xc7, 0x10, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0xaf, 0xff, 0xd9, 0x79, 0xef, 0xff, + 0x80, 0x0, 0x7f, 0xff, 0x70, 0x0, 0x0, 0x8f, + 0xff, 0x40, 0xe, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x9f, 0xfd, 0x5, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf3, 0x9f, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0x7b, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf9, 0xcf, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xbc, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xfa, 0xbf, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0x99, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf7, 0x5f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x30, 0xef, + 0xf7, 0x0, 0x0, 0x0, 0x8, 0xff, 0xd0, 0x7, + 0xff, 0xf6, 0x0, 0x0, 0x8, 0xff, 0xf5, 0x0, + 0xa, 0xff, 0xfd, 0x87, 0x9d, 0xff, 0xf8, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x1, 0x8c, 0xef, 0xec, 0x71, 0x0, + 0x0, + + /* U+03C0 "π" */ + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb4, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x16, + 0x66, 0x6c, 0xff, 0xa6, 0x66, 0x66, 0x69, 0xff, + 0xd6, 0x66, 0x40, 0x0, 0x0, 0x9f, 0xf6, 0x0, + 0x0, 0x0, 0x4f, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0x60, 0x0, 0x0, 0x4, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf6, 0x0, 0x0, + 0x0, 0x4f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0x60, 0x0, 0x0, 0x4, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf6, 0x0, 0x0, 0x0, + 0x4f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0x60, 0x0, 0x0, 0x4, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf6, 0x0, 0x0, 0x0, 0x4f, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0x60, + 0x0, 0x0, 0x4, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xf6, 0x0, 0x0, 0x0, 0x4f, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0x60, 0x0, + 0x0, 0x4, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf6, 0x0, 0x0, 0x0, 0x4f, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0x60, 0x0, 0x0, + 0x4, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xf6, 0x0, 0x0, 0x0, 0x4f, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0x60, 0x0, 0x0, 0x4, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf6, + 0x0, 0x0, 0x0, 0x4f, 0xfb, 0x0, 0x0, + + /* U+03C1 "ρ" */ + 0x0, 0x0, 0x5a, 0xef, 0xfd, 0x93, 0x0, 0x0, + 0x0, 0x1, 0xcf, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xb8, 0x8b, 0xff, 0xfc, + 0x0, 0x0, 0x8f, 0xfe, 0x30, 0x0, 0x3, 0xef, + 0xf9, 0x0, 0xf, 0xff, 0x40, 0x0, 0x0, 0x2, + 0xff, 0xf2, 0x4, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0x90, 0x8f, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xfd, 0xa, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf0, 0xcf, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0x1c, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xf1, 0xdf, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xd, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xd0, 0xdf, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, 0xd, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x30, 0xdf, + 0xff, 0xe2, 0x0, 0x0, 0x2d, 0xff, 0xa0, 0xd, + 0xff, 0xff, 0xfb, 0x77, 0xbf, 0xff, 0xd1, 0x0, + 0xdf, 0xf6, 0xef, 0xff, 0xff, 0xff, 0xc1, 0x0, + 0xd, 0xff, 0x21, 0x7c, 0xef, 0xeb, 0x50, 0x0, + 0x0, 0xdf, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03C2 "ς" */ + 0x0, 0x0, 0x0, 0x27, 0xce, 0xff, 0xec, 0x80, + 0x0, 0x0, 0x2a, 0xff, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0x4, 0xef, 0xff, 0xb8, 0x78, 0xad, 0x70, + 0x0, 0x3f, 0xff, 0x91, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xc5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2d, 0xff, 0xff, 0xfb, 0x61, 0x0, 0x0, + 0x0, 0x0, 0x7e, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x49, 0xdf, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xaf, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xbf, 0xfe, 0x0, + 0x0, 0x0, 0x1, 0xec, 0xdf, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x7, 0xef, 0xfd, 0x82, 0x0, 0x0, + + /* U+03C3 "σ" */ + 0x0, 0x0, 0x18, 0xce, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf3, 0x0, 0xaf, 0xff, 0xd8, + 0x79, 0xef, 0xff, 0xc6, 0x66, 0x61, 0x7, 0xff, + 0xf6, 0x0, 0x0, 0x8, 0xff, 0xf4, 0x0, 0x0, + 0x1f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x9f, 0xfd, + 0x0, 0x0, 0x6f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x30, 0x0, 0xaf, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0x60, 0x0, 0xcf, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x80, 0x0, + 0xdf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0x90, 0x0, 0xdf, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0x90, 0x0, 0xcf, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0x80, 0x0, 0xaf, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0x50, 0x0, + 0x6f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0x20, 0x0, 0x1f, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x9f, 0xfc, 0x0, 0x0, 0x8, 0xff, 0xf5, 0x0, + 0x0, 0x8, 0xff, 0xf3, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xc8, 0x79, 0xef, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xe5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x28, 0xce, 0xfe, 0xb7, + 0x0, 0x0, 0x0, 0x0, + + /* U+03C4 "τ" */ + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa3, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x16, 0x66, 0x6c, + 0xff, 0xa6, 0x66, 0x40, 0x0, 0x0, 0x9f, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xf6, 0x0, 0x0, + + /* U+03C5 "υ" */ + 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x9, 0xff, 0x6b, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x9f, 0xf6, 0xbf, + 0xf4, 0x0, 0x0, 0x0, 0x9, 0xff, 0x6b, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x9f, 0xf6, 0xbf, 0xf4, + 0x0, 0x0, 0x0, 0x9, 0xff, 0x6b, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x9f, 0xf6, 0xbf, 0xf4, 0x0, + 0x0, 0x0, 0x9, 0xff, 0x6b, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x9f, 0xf6, 0xbf, 0xf4, 0x0, 0x0, + 0x0, 0x9, 0xff, 0x6b, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x9f, 0xf6, 0xbf, 0xf4, 0x0, 0x0, 0x0, + 0xa, 0xff, 0x5b, 0xff, 0x50, 0x0, 0x0, 0x0, + 0xaf, 0xf4, 0x9f, 0xf7, 0x0, 0x0, 0x0, 0xd, + 0xff, 0x26, 0xff, 0xd0, 0x0, 0x0, 0x3, 0xff, + 0xe0, 0x1e, 0xff, 0xa0, 0x0, 0x2, 0xef, 0xf8, + 0x0, 0x5f, 0xff, 0xe8, 0x7a, 0xff, 0xfd, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xfc, 0x10, 0x0, + 0x0, 0x28, 0xdf, 0xfe, 0xb5, 0x0, 0x0, + + /* U+03C6 "φ" */ + 0x0, 0x0, 0x4b, 0xe2, 0x1, 0x9e, 0xfe, 0xc6, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xe0, 0xc, 0xff, + 0xff, 0xff, 0xd2, 0x0, 0x0, 0xbf, 0xff, 0x80, + 0x2f, 0xff, 0xb8, 0xdf, 0xfe, 0x10, 0x7, 0xff, + 0xe3, 0x0, 0x4f, 0xfd, 0x0, 0xa, 0xff, 0x90, + 0xe, 0xff, 0x30, 0x0, 0x5f, 0xfa, 0x0, 0x0, + 0xef, 0xf1, 0x5f, 0xfc, 0x0, 0x0, 0x5f, 0xfa, + 0x0, 0x0, 0x9f, 0xf7, 0x9f, 0xf7, 0x0, 0x0, + 0x5f, 0xfa, 0x0, 0x0, 0x5f, 0xfb, 0xbf, 0xf5, + 0x0, 0x0, 0x5f, 0xfa, 0x0, 0x0, 0x4f, 0xfd, + 0xcf, 0xf4, 0x0, 0x0, 0x5f, 0xfa, 0x0, 0x0, + 0x4f, 0xfd, 0xbf, 0xf5, 0x0, 0x0, 0x5f, 0xfa, + 0x0, 0x0, 0x6f, 0xfb, 0x9f, 0xf8, 0x0, 0x0, + 0x5f, 0xfa, 0x0, 0x0, 0x9f, 0xf9, 0x5f, 0xfd, + 0x0, 0x0, 0x5f, 0xfa, 0x0, 0x0, 0xef, 0xf4, + 0x1f, 0xff, 0x50, 0x0, 0x5f, 0xfa, 0x0, 0x6, + 0xff, 0xd0, 0x8, 0xff, 0xe2, 0x0, 0x5f, 0xfa, + 0x0, 0x3f, 0xff, 0x50, 0x0, 0xcf, 0xfe, 0x50, + 0x5f, 0xfa, 0x6, 0xff, 0xf9, 0x0, 0x0, 0x1d, + 0xff, 0xfd, 0xcf, 0xfe, 0xef, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x3, 0x9d, 0xff, 0xff, + 0xc7, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfa, 0x0, 0x0, + 0x0, 0x0, + + /* U+03C7 "χ" */ + 0xe, 0xff, 0x40, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xe0, 0x7, 0xff, 0xc0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0x60, 0x0, 0xef, 0xf4, 0x0, 0x0, 0x0, + 0x5f, 0xfd, 0x0, 0x0, 0x6f, 0xfb, 0x0, 0x0, + 0x0, 0xdf, 0xf5, 0x0, 0x0, 0xe, 0xff, 0x30, + 0x0, 0x5, 0xff, 0xd0, 0x0, 0x0, 0x6, 0xff, + 0xb0, 0x0, 0xd, 0xff, 0x40, 0x0, 0x0, 0x0, + 0xef, 0xf3, 0x0, 0x5f, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xfb, 0x0, 0xdf, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0x25, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xad, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xef, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0x6a, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xfe, 0x2, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xf6, 0x0, 0xaf, 0xf7, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xe0, 0x0, 0x2f, + 0xff, 0x10, 0x0, 0x0, 0xb, 0xff, 0x60, 0x0, + 0xa, 0xff, 0x90, 0x0, 0x0, 0x4f, 0xfe, 0x0, + 0x0, 0x2, 0xff, 0xf2, 0x0, 0x0, 0xdf, 0xf6, + 0x0, 0x0, 0x0, 0xaf, 0xfa, 0x0, 0x5, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x30, 0xe, + 0xff, 0x60, 0x0, 0x0, 0x0, 0xa, 0xff, 0xb0, + 0x7f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xf4, + + /* U+03C8 "ψ" */ + 0xff, 0xf0, 0x0, 0x0, 0x6f, 0xf9, 0x0, 0x0, + 0xc, 0xff, 0x3f, 0xff, 0x0, 0x0, 0x6, 0xff, + 0x90, 0x0, 0x0, 0xcf, 0xf3, 0xff, 0xf0, 0x0, + 0x0, 0x6f, 0xf9, 0x0, 0x0, 0xc, 0xff, 0x3f, + 0xff, 0x0, 0x0, 0x6, 0xff, 0x90, 0x0, 0x0, + 0xcf, 0xf3, 0xff, 0xf0, 0x0, 0x0, 0x6f, 0xf9, + 0x0, 0x0, 0xc, 0xff, 0x3f, 0xff, 0x0, 0x0, + 0x6, 0xff, 0x90, 0x0, 0x0, 0xcf, 0xf3, 0xff, + 0xf0, 0x0, 0x0, 0x6f, 0xf9, 0x0, 0x0, 0xc, + 0xff, 0x3f, 0xff, 0x0, 0x0, 0x6, 0xff, 0x90, + 0x0, 0x0, 0xcf, 0xf3, 0xff, 0xf0, 0x0, 0x0, + 0x6f, 0xf9, 0x0, 0x0, 0xc, 0xff, 0x3f, 0xff, + 0x0, 0x0, 0x6, 0xff, 0x90, 0x0, 0x0, 0xcf, + 0xf2, 0xef, 0xf1, 0x0, 0x0, 0x6f, 0xf9, 0x0, + 0x0, 0xd, 0xff, 0x2d, 0xff, 0x20, 0x0, 0x6, + 0xff, 0x90, 0x0, 0x0, 0xff, 0xf0, 0xbf, 0xf6, + 0x0, 0x0, 0x6f, 0xf9, 0x0, 0x0, 0x3f, 0xfe, + 0x6, 0xff, 0xe1, 0x0, 0x6, 0xff, 0x90, 0x0, + 0xb, 0xff, 0xa0, 0xd, 0xff, 0xd2, 0x0, 0x6f, + 0xf9, 0x0, 0x1b, 0xff, 0xf3, 0x0, 0x3f, 0xff, + 0xfc, 0x9b, 0xff, 0xc9, 0xbf, 0xff, 0xf7, 0x0, + 0x0, 0x2d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe5, 0x0, 0x0, 0x0, 0x4, 0x9d, 0xef, 0xff, + 0xff, 0xdb, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03C9 "ω" */ + 0x0, 0x3f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xfb, 0x0, 0x0, 0xa, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf3, + 0x0, 0x2, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xb0, 0x0, 0x8f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x10, 0xd, 0xff, 0x40, 0x0, 0x0, 0x19, + 0x96, 0x0, 0x0, 0x0, 0xbf, 0xf6, 0x1, 0xff, + 0xf0, 0x0, 0x0, 0x3, 0xff, 0xc0, 0x0, 0x0, + 0x7, 0xff, 0xa0, 0x5f, 0xfc, 0x0, 0x0, 0x0, + 0x3f, 0xfc, 0x0, 0x0, 0x0, 0x3f, 0xfd, 0x7, + 0xff, 0x90, 0x0, 0x0, 0x3, 0xff, 0xc0, 0x0, + 0x0, 0x1, 0xff, 0xf0, 0x8f, 0xf8, 0x0, 0x0, + 0x0, 0x3f, 0xfc, 0x0, 0x0, 0x0, 0xf, 0xff, + 0x18, 0xff, 0x70, 0x0, 0x0, 0x3, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0xff, 0xf1, 0x7f, 0xf8, 0x0, + 0x0, 0x0, 0x4f, 0xfc, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x5, 0xff, 0xb0, 0x0, 0x0, 0x5, 0xff, + 0xd0, 0x0, 0x0, 0x2, 0xff, 0xe0, 0x2f, 0xfe, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0x0, 0x0, 0x0, + 0x6f, 0xfb, 0x0, 0xdf, 0xf5, 0x0, 0x0, 0xc, + 0xff, 0xf5, 0x0, 0x0, 0xc, 0xff, 0x60, 0x7, + 0xff, 0xe1, 0x0, 0x7, 0xff, 0x8f, 0xe1, 0x0, + 0x7, 0xff, 0xf1, 0x0, 0xd, 0xff, 0xe7, 0x6b, + 0xff, 0x70, 0xef, 0xe8, 0x5a, 0xff, 0xf6, 0x0, + 0x0, 0x1d, 0xff, 0xff, 0xff, 0x90, 0x2, 0xef, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x7, 0xdf, + 0xec, 0x50, 0x0, 0x1, 0x8d, 0xfe, 0xa3, 0x0, + 0x0, + + /* U+03CA "ϊ" */ + 0xef, 0xf3, 0x0, 0xbf, 0xf6, 0xef, 0xf3, 0x0, + 0xbf, 0xf6, 0xef, 0xf3, 0x0, 0xbf, 0xf6, 0x56, + 0x61, 0x0, 0x46, 0x62, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0x40, 0x0, 0x0, 0xb, 0xff, 0x40, 0x0, + 0x0, 0xb, 0xff, 0x40, 0x0, 0x0, 0xb, 0xff, + 0x40, 0x0, 0x0, 0xb, 0xff, 0x40, 0x0, 0x0, + 0xb, 0xff, 0x40, 0x0, 0x0, 0xb, 0xff, 0x40, + 0x0, 0x0, 0xb, 0xff, 0x40, 0x0, 0x0, 0xb, + 0xff, 0x40, 0x0, 0x0, 0xb, 0xff, 0x40, 0x0, + 0x0, 0xb, 0xff, 0x40, 0x0, 0x0, 0xb, 0xff, + 0x40, 0x0, 0x0, 0xb, 0xff, 0x40, 0x0, 0x0, + 0xb, 0xff, 0x40, 0x0, 0x0, 0xb, 0xff, 0x40, + 0x0, 0x0, 0xb, 0xff, 0x40, 0x0, 0x0, 0xb, + 0xff, 0x40, 0x0, 0x0, 0xb, 0xff, 0x40, 0x0, + + /* U+03CB "ϋ" */ + 0x0, 0x5f, 0xfc, 0x0, 0x2f, 0xff, 0x0, 0x0, + 0x5, 0xff, 0xc0, 0x2, 0xff, 0xf0, 0x0, 0x0, + 0x5f, 0xfc, 0x0, 0x2f, 0xff, 0x0, 0x0, 0x2, + 0x66, 0x40, 0x1, 0x66, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf4, 0x0, + 0x0, 0x0, 0x9, 0xff, 0x6b, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x9f, 0xf6, 0xbf, 0xf4, 0x0, 0x0, + 0x0, 0x9, 0xff, 0x6b, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x9f, 0xf6, 0xbf, 0xf4, 0x0, 0x0, 0x0, + 0x9, 0xff, 0x6b, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x9f, 0xf6, 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x9, + 0xff, 0x6b, 0xff, 0x40, 0x0, 0x0, 0x0, 0x9f, + 0xf6, 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x9, 0xff, + 0x6b, 0xff, 0x40, 0x0, 0x0, 0x0, 0x9f, 0xf6, + 0xbf, 0xf4, 0x0, 0x0, 0x0, 0xa, 0xff, 0x5b, + 0xff, 0x50, 0x0, 0x0, 0x0, 0xaf, 0xf4, 0x9f, + 0xf7, 0x0, 0x0, 0x0, 0xd, 0xff, 0x26, 0xff, + 0xd0, 0x0, 0x0, 0x3, 0xff, 0xe0, 0x1e, 0xff, + 0xa0, 0x0, 0x2, 0xef, 0xf8, 0x0, 0x5f, 0xff, + 0xe8, 0x7a, 0xff, 0xfd, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xfc, 0x10, 0x0, 0x0, 0x28, 0xdf, + 0xfe, 0xb5, 0x0, 0x0, + + /* U+03CC "ό" */ + 0x0, 0x0, 0x0, 0x0, 0x4a, 0xaa, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x17, 0xce, + 0xfe, 0xc7, 0x10, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0xaf, 0xff, + 0xd9, 0x79, 0xef, 0xff, 0x80, 0x0, 0x7f, 0xff, + 0x70, 0x0, 0x0, 0x8f, 0xff, 0x40, 0xe, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x9f, 0xfd, 0x5, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf3, 0x9f, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0x7b, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, + 0xcf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xbc, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xfa, 0xbf, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0x99, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xf7, 0x5f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0x30, 0xef, 0xf7, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xd0, 0x7, 0xff, 0xf6, 0x0, 0x0, + 0x8, 0xff, 0xf5, 0x0, 0xa, 0xff, 0xfd, 0x87, + 0x9d, 0xff, 0xf8, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x1, 0x8c, + 0xef, 0xec, 0x71, 0x0, 0x0, + + /* U+03CD "ύ" */ + 0x0, 0x0, 0x0, 0x6, 0xaa, 0xa2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf4, 0x0, 0x0, + 0x0, 0x9, 0xff, 0x6b, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x9f, 0xf6, 0xbf, 0xf4, 0x0, 0x0, 0x0, + 0x9, 0xff, 0x6b, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x9f, 0xf6, 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x9, + 0xff, 0x6b, 0xff, 0x40, 0x0, 0x0, 0x0, 0x9f, + 0xf6, 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x9, 0xff, + 0x6b, 0xff, 0x40, 0x0, 0x0, 0x0, 0x9f, 0xf6, + 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x9, 0xff, 0x6b, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x9f, 0xf6, 0xbf, + 0xf4, 0x0, 0x0, 0x0, 0xa, 0xff, 0x5b, 0xff, + 0x50, 0x0, 0x0, 0x0, 0xaf, 0xf4, 0x9f, 0xf7, + 0x0, 0x0, 0x0, 0xd, 0xff, 0x26, 0xff, 0xd0, + 0x0, 0x0, 0x3, 0xff, 0xe0, 0x1e, 0xff, 0xa0, + 0x0, 0x2, 0xef, 0xf8, 0x0, 0x5f, 0xff, 0xe8, + 0x7a, 0xff, 0xfd, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xff, 0xfc, 0x10, 0x0, 0x0, 0x28, 0xdf, 0xfe, + 0xb5, 0x0, 0x0, + + /* U+03CE "ώ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6a, 0xaa, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfb, 0x0, + 0x0, 0xa, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xf3, 0x0, 0x2, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xb0, 0x0, 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x10, 0xd, 0xff, + 0x40, 0x0, 0x0, 0x19, 0x96, 0x0, 0x0, 0x0, + 0xbf, 0xf6, 0x1, 0xff, 0xf0, 0x0, 0x0, 0x3, + 0xff, 0xc0, 0x0, 0x0, 0x7, 0xff, 0xa0, 0x5f, + 0xfc, 0x0, 0x0, 0x0, 0x3f, 0xfc, 0x0, 0x0, + 0x0, 0x3f, 0xfd, 0x7, 0xff, 0x90, 0x0, 0x0, + 0x3, 0xff, 0xc0, 0x0, 0x0, 0x1, 0xff, 0xf0, + 0x8f, 0xf8, 0x0, 0x0, 0x0, 0x3f, 0xfc, 0x0, + 0x0, 0x0, 0xf, 0xff, 0x18, 0xff, 0x70, 0x0, + 0x0, 0x3, 0xff, 0xc0, 0x0, 0x0, 0x0, 0xff, + 0xf1, 0x7f, 0xf8, 0x0, 0x0, 0x0, 0x4f, 0xfc, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x5, 0xff, 0xb0, + 0x0, 0x0, 0x5, 0xff, 0xd0, 0x0, 0x0, 0x2, + 0xff, 0xe0, 0x2f, 0xfe, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0x0, 0x6f, 0xfb, 0x0, 0xdf, + 0xf5, 0x0, 0x0, 0xc, 0xff, 0xf5, 0x0, 0x0, + 0xc, 0xff, 0x60, 0x7, 0xff, 0xe1, 0x0, 0x7, + 0xff, 0x8f, 0xe1, 0x0, 0x7, 0xff, 0xf1, 0x0, + 0xd, 0xff, 0xe7, 0x6b, 0xff, 0x70, 0xef, 0xe8, + 0x5a, 0xff, 0xf6, 0x0, 0x0, 0x1d, 0xff, 0xff, + 0xff, 0x90, 0x2, 0xef, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x7, 0xdf, 0xec, 0x50, 0x0, 0x1, + 0x8d, 0xfe, 0xa3, 0x0, 0x0, + + /* U+03F4 "ϴ" */ + 0x0, 0x0, 0x0, 0x28, 0x85, 0x0, 0x0, 0x22, + 0x10, 0xb, 0xff, 0x22, 0x21, 0x5f, 0xf8, 0x3, + 0xff, 0x52, 0xff, 0xb5, 0xff, 0x80, 0xaf, 0xa0, + 0x2f, 0xfb, 0x5f, 0xf8, 0x2f, 0xd0, 0x2, 0xff, + 0xb0 +}; + + +/*--------------------- + * GLYPH DESCRIPTION + *--------------------*/ + +static const lv_font_fmt_txt_glyph_dsc_t glyph_dsc[] = { + {.bitmap_index = 0, .adv_w = 0, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0} /* id = 0 reserved */, + {.bitmap_index = 0, .adv_w = 151, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 0, .adv_w = 152, .box_w = 5, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 60, .adv_w = 193, .box_w = 10, .box_h = 9, .ofs_x = 1, .ofs_y = 15}, + {.bitmap_index = 105, .adv_w = 303, .box_w = 19, .box_h = 24, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 333, .adv_w = 303, .box_w = 17, .box_h = 30, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 588, .adv_w = 484, .box_w = 27, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 912, .adv_w = 363, .box_w = 21, .box_h = 25, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 1175, .adv_w = 103, .box_w = 4, .box_h = 9, .ofs_x = 1, .ofs_y = 15}, + {.bitmap_index = 1193, .adv_w = 181, .box_w = 9, .box_h = 31, .ofs_x = 2, .ofs_y = -7}, + {.bitmap_index = 1333, .adv_w = 181, .box_w = 9, .box_h = 31, .ofs_x = 1, .ofs_y = -7}, + {.bitmap_index = 1473, .adv_w = 211, .box_w = 12, .box_h = 11, .ofs_x = 1, .ofs_y = 13}, + {.bitmap_index = 1539, .adv_w = 318, .box_w = 17, .box_h = 17, .ofs_x = 1, .ofs_y = 4}, + {.bitmap_index = 1684, .adv_w = 152, .box_w = 5, .box_h = 9, .ofs_x = 2, .ofs_y = -5}, + {.bitmap_index = 1707, .adv_w = 181, .box_w = 10, .box_h = 3, .ofs_x = 1, .ofs_y = 7}, + {.bitmap_index = 1722, .adv_w = 152, .box_w = 4, .box_h = 4, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 1730, .adv_w = 151, .box_w = 10, .box_h = 24, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1850, .adv_w = 303, .box_w = 17, .box_h = 24, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2054, .adv_w = 303, .box_w = 10, .box_h = 24, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 2174, .adv_w = 303, .box_w = 17, .box_h = 24, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2378, .adv_w = 303, .box_w = 17, .box_h = 24, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2582, .adv_w = 303, .box_w = 18, .box_h = 24, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2798, .adv_w = 303, .box_w = 17, .box_h = 24, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3002, .adv_w = 303, .box_w = 17, .box_h = 24, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3206, .adv_w = 303, .box_w = 17, .box_h = 24, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3410, .adv_w = 303, .box_w = 17, .box_h = 24, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3614, .adv_w = 303, .box_w = 17, .box_h = 24, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3818, .adv_w = 152, .box_w = 4, .box_h = 18, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 3854, .adv_w = 152, .box_w = 5, .box_h = 23, .ofs_x = 2, .ofs_y = -5}, + {.bitmap_index = 3912, .adv_w = 318, .box_w = 17, .box_h = 18, .ofs_x = 1, .ofs_y = 3}, + {.bitmap_index = 4065, .adv_w = 318, .box_w = 17, .box_h = 10, .ofs_x = 1, .ofs_y = 7}, + {.bitmap_index = 4150, .adv_w = 318, .box_w = 17, .box_h = 18, .ofs_x = 1, .ofs_y = 3}, + {.bitmap_index = 4303, .adv_w = 303, .box_w = 17, .box_h = 24, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4507, .adv_w = 552, .box_w = 33, .box_h = 31, .ofs_x = 1, .ofs_y = -7}, + {.bitmap_index = 5019, .adv_w = 363, .box_w = 24, .box_h = 24, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 5307, .adv_w = 363, .box_w = 19, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 5535, .adv_w = 393, .box_w = 23, .box_h = 24, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 5811, .adv_w = 393, .box_w = 21, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 6063, .adv_w = 363, .box_w = 19, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 6291, .adv_w = 333, .box_w = 18, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 6507, .adv_w = 423, .box_w = 24, .box_h = 24, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 6795, .adv_w = 393, .box_w = 20, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 7035, .adv_w = 152, .box_w = 4, .box_h = 24, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 7083, .adv_w = 272, .box_w = 15, .box_h = 24, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 7263, .adv_w = 363, .box_w = 21, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 7515, .adv_w = 303, .box_w = 16, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 7707, .adv_w = 453, .box_w = 24, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 7995, .adv_w = 393, .box_w = 20, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 8235, .adv_w = 423, .box_w = 24, .box_h = 24, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 8523, .adv_w = 363, .box_w = 20, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 8763, .adv_w = 423, .box_w = 25, .box_h = 26, .ofs_x = 1, .ofs_y = -2}, + {.bitmap_index = 9088, .adv_w = 393, .box_w = 23, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 9364, .adv_w = 363, .box_w = 20, .box_h = 24, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 9604, .adv_w = 333, .box_w = 21, .box_h = 24, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 9856, .adv_w = 393, .box_w = 20, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 10096, .adv_w = 363, .box_w = 23, .box_h = 24, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 10372, .adv_w = 513, .box_w = 32, .box_h = 24, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 10756, .adv_w = 363, .box_w = 23, .box_h = 24, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 11032, .adv_w = 363, .box_w = 23, .box_h = 24, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 11308, .adv_w = 333, .box_w = 20, .box_h = 24, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 11548, .adv_w = 152, .box_w = 7, .box_h = 31, .ofs_x = 2, .ofs_y = -7}, + {.bitmap_index = 11657, .adv_w = 151, .box_w = 10, .box_h = 24, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 11777, .adv_w = 152, .box_w = 8, .box_h = 31, .ofs_x = 0, .ofs_y = -7}, + {.bitmap_index = 11901, .adv_w = 255, .box_w = 16, .box_h = 14, .ofs_x = 0, .ofs_y = 11}, + {.bitmap_index = 12013, .adv_w = 303, .box_w = 21, .box_h = 3, .ofs_x = -1, .ofs_y = -7}, + {.bitmap_index = 12045, .adv_w = 181, .box_w = 7, .box_h = 5, .ofs_x = 1, .ofs_y = 20}, + {.bitmap_index = 12063, .adv_w = 303, .box_w = 17, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 12216, .adv_w = 303, .box_w = 16, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 12408, .adv_w = 272, .box_w = 16, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 12552, .adv_w = 303, .box_w = 16, .box_h = 24, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 12744, .adv_w = 303, .box_w = 17, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 12897, .adv_w = 152, .box_w = 11, .box_h = 24, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 13029, .adv_w = 303, .box_w = 16, .box_h = 25, .ofs_x = 1, .ofs_y = -7}, + {.bitmap_index = 13229, .adv_w = 303, .box_w = 15, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 13409, .adv_w = 121, .box_w = 4, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 13457, .adv_w = 121, .box_w = 8, .box_h = 31, .ofs_x = -2, .ofs_y = -7}, + {.bitmap_index = 13581, .adv_w = 272, .box_w = 15, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 13761, .adv_w = 121, .box_w = 4, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 13809, .adv_w = 453, .box_w = 25, .box_h = 18, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 14034, .adv_w = 303, .box_w = 15, .box_h = 18, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 14169, .adv_w = 303, .box_w = 17, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 14322, .adv_w = 303, .box_w = 16, .box_h = 25, .ofs_x = 2, .ofs_y = -7}, + {.bitmap_index = 14522, .adv_w = 303, .box_w = 16, .box_h = 25, .ofs_x = 1, .ofs_y = -7}, + {.bitmap_index = 14722, .adv_w = 181, .box_w = 10, .box_h = 18, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 14812, .adv_w = 272, .box_w = 15, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 14947, .adv_w = 152, .box_w = 10, .box_h = 25, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 15072, .adv_w = 303, .box_w = 15, .box_h = 18, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 15207, .adv_w = 272, .box_w = 17, .box_h = 18, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 15360, .adv_w = 393, .box_w = 25, .box_h = 18, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 15585, .adv_w = 272, .box_w = 17, .box_h = 18, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 15738, .adv_w = 272, .box_w = 17, .box_h = 25, .ofs_x = 0, .ofs_y = -7}, + {.bitmap_index = 15951, .adv_w = 272, .box_w = 17, .box_h = 18, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 16104, .adv_w = 181, .box_w = 11, .box_h = 31, .ofs_x = 0, .ofs_y = -7}, + {.bitmap_index = 16275, .adv_w = 141, .box_w = 3, .box_h = 31, .ofs_x = 3, .ofs_y = -7}, + {.bitmap_index = 16322, .adv_w = 181, .box_w = 11, .box_h = 31, .ofs_x = 0, .ofs_y = -7}, + {.bitmap_index = 16493, .adv_w = 318, .box_w = 18, .box_h = 7, .ofs_x = 1, .ofs_y = 8}, + {.bitmap_index = 16556, .adv_w = 151, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 16556, .adv_w = 303, .box_w = 19, .box_h = 25, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 16794, .adv_w = 303, .box_w = 17, .box_h = 18, .ofs_x = 1, .ofs_y = 3}, + {.bitmap_index = 16947, .adv_w = 303, .box_w = 19, .box_h = 24, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 17175, .adv_w = 142, .box_w = 3, .box_h = 31, .ofs_x = 3, .ofs_y = -7}, + {.bitmap_index = 17222, .adv_w = 303, .box_w = 17, .box_h = 31, .ofs_x = 1, .ofs_y = -7}, + {.bitmap_index = 17486, .adv_w = 181, .box_w = 10, .box_h = 4, .ofs_x = 1, .ofs_y = 21}, + {.bitmap_index = 17506, .adv_w = 401, .box_w = 26, .box_h = 25, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 17831, .adv_w = 204, .box_w = 13, .box_h = 13, .ofs_x = 0, .ofs_y = 12}, + {.bitmap_index = 17916, .adv_w = 303, .box_w = 15, .box_h = 16, .ofs_x = 2, .ofs_y = 1}, + {.bitmap_index = 18036, .adv_w = 318, .box_w = 17, .box_h = 10, .ofs_x = 1, .ofs_y = 7}, + {.bitmap_index = 18121, .adv_w = 181, .box_w = 10, .box_h = 3, .ofs_x = 1, .ofs_y = 7}, + {.bitmap_index = 18136, .adv_w = 401, .box_w = 26, .box_h = 25, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 18461, .adv_w = 218, .box_w = 10, .box_h = 9, .ofs_x = 2, .ofs_y = 16}, + {.bitmap_index = 18506, .adv_w = 318, .box_w = 17, .box_h = 21, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 18685, .adv_w = 181, .box_w = 11, .box_h = 13, .ofs_x = 0, .ofs_y = 12}, + {.bitmap_index = 18757, .adv_w = 181, .box_w = 11, .box_h = 13, .ofs_x = 0, .ofs_y = 12}, + {.bitmap_index = 18829, .adv_w = 303, .box_w = 15, .box_h = 25, .ofs_x = 2, .ofs_y = -7}, + {.bitmap_index = 19017, .adv_w = 292, .box_w = 20, .box_h = 31, .ofs_x = -1, .ofs_y = -7}, + {.bitmap_index = 19327, .adv_w = 152, .box_w = 4, .box_h = 4, .ofs_x = 3, .ofs_y = 10}, + {.bitmap_index = 19335, .adv_w = 303, .box_w = 15, .box_h = 16, .ofs_x = 2, .ofs_y = 1}, + {.bitmap_index = 19455, .adv_w = 454, .box_w = 27, .box_h = 26, .ofs_x = 1, .ofs_y = -2}, + {.bitmap_index = 19806, .adv_w = 181, .box_w = 7, .box_h = 5, .ofs_x = 3, .ofs_y = 20}, + {.bitmap_index = 19824, .adv_w = 363, .box_w = 24, .box_h = 24, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 20112, .adv_w = 427, .box_w = 27, .box_h = 24, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 20436, .adv_w = 456, .box_w = 28, .box_h = 24, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 20772, .adv_w = 209, .box_w = 12, .box_h = 24, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 20916, .adv_w = 421, .box_w = 27, .box_h = 24, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 21240, .adv_w = 465, .box_w = 31, .box_h = 24, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 21612, .adv_w = 409, .box_w = 26, .box_h = 24, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 21924, .adv_w = 121, .box_w = 13, .box_h = 25, .ofs_x = -3, .ofs_y = 0}, + {.bitmap_index = 22087, .adv_w = 363, .box_w = 24, .box_h = 24, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 22375, .adv_w = 363, .box_w = 19, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 22603, .adv_w = 300, .box_w = 16, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 22795, .adv_w = 363, .box_w = 24, .box_h = 24, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 23083, .adv_w = 363, .box_w = 19, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 23311, .adv_w = 333, .box_w = 20, .box_h = 24, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 23551, .adv_w = 393, .box_w = 20, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 23791, .adv_w = 423, .box_w = 24, .box_h = 24, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 24079, .adv_w = 152, .box_w = 4, .box_h = 24, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 24127, .adv_w = 363, .box_w = 21, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 24379, .adv_w = 363, .box_w = 23, .box_h = 24, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 24655, .adv_w = 453, .box_w = 24, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 24943, .adv_w = 393, .box_w = 20, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 25183, .adv_w = 354, .box_w = 20, .box_h = 24, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 25423, .adv_w = 423, .box_w = 24, .box_h = 24, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 25711, .adv_w = 393, .box_w = 20, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 25951, .adv_w = 363, .box_w = 20, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 26191, .adv_w = 336, .box_w = 18, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 26407, .adv_w = 333, .box_w = 21, .box_h = 24, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 26659, .adv_w = 363, .box_w = 23, .box_h = 24, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 26935, .adv_w = 434, .box_w = 25, .box_h = 26, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 27260, .adv_w = 363, .box_w = 23, .box_h = 24, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 27536, .adv_w = 454, .box_w = 25, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 27836, .adv_w = 407, .box_w = 23, .box_h = 24, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 28112, .adv_w = 152, .box_w = 11, .box_h = 29, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 28272, .adv_w = 363, .box_w = 23, .box_h = 29, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 28606, .adv_w = 315, .box_w = 18, .box_h = 26, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 28840, .adv_w = 243, .box_w = 14, .box_h = 26, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 29022, .adv_w = 303, .box_w = 15, .box_h = 32, .ofs_x = 2, .ofs_y = -7}, + {.bitmap_index = 29262, .adv_w = 121, .box_w = 7, .box_h = 25, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 29350, .adv_w = 298, .box_w = 15, .box_h = 26, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 29545, .adv_w = 315, .box_w = 18, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 29707, .adv_w = 313, .box_w = 17, .box_h = 31, .ofs_x = 2, .ofs_y = -7}, + {.bitmap_index = 29971, .adv_w = 272, .box_w = 17, .box_h = 25, .ofs_x = 0, .ofs_y = -7}, + {.bitmap_index = 30184, .adv_w = 303, .box_w = 17, .box_h = 24, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 30388, .adv_w = 243, .box_w = 14, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 30514, .adv_w = 240, .box_w = 14, .box_h = 31, .ofs_x = 1, .ofs_y = -7}, + {.bitmap_index = 30731, .adv_w = 303, .box_w = 15, .box_h = 25, .ofs_x = 2, .ofs_y = -7}, + {.bitmap_index = 30919, .adv_w = 303, .box_w = 17, .box_h = 24, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 31123, .adv_w = 121, .box_w = 4, .box_h = 18, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 31159, .adv_w = 271, .box_w = 15, .box_h = 18, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 31294, .adv_w = 272, .box_w = 17, .box_h = 24, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 31498, .adv_w = 303, .box_w = 15, .box_h = 25, .ofs_x = 2, .ofs_y = -7}, + {.bitmap_index = 31686, .adv_w = 272, .box_w = 17, .box_h = 18, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 31839, .adv_w = 244, .box_w = 14, .box_h = 31, .ofs_x = 1, .ofs_y = -7}, + {.bitmap_index = 32056, .adv_w = 303, .box_w = 17, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 32209, .adv_w = 375, .box_w = 23, .box_h = 18, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 32416, .adv_w = 309, .box_w = 17, .box_h = 25, .ofs_x = 2, .ofs_y = -7}, + {.bitmap_index = 32629, .adv_w = 262, .box_w = 16, .box_h = 25, .ofs_x = 1, .ofs_y = -7}, + {.bitmap_index = 32829, .adv_w = 336, .box_w = 20, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 33009, .adv_w = 215, .box_w = 13, .box_h = 18, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 33126, .adv_w = 298, .box_w = 15, .box_h = 18, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 33261, .adv_w = 353, .box_w = 20, .box_h = 25, .ofs_x = 1, .ofs_y = -7}, + {.bitmap_index = 33511, .adv_w = 286, .box_w = 18, .box_h = 25, .ofs_x = 0, .ofs_y = -7}, + {.bitmap_index = 33736, .adv_w = 388, .box_w = 21, .box_h = 25, .ofs_x = 2, .ofs_y = -7}, + {.bitmap_index = 33999, .adv_w = 425, .box_w = 25, .box_h = 18, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 34224, .adv_w = 121, .box_w = 10, .box_h = 24, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 34344, .adv_w = 298, .box_w = 15, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 34524, .adv_w = 303, .box_w = 17, .box_h = 26, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 34745, .adv_w = 298, .box_w = 15, .box_h = 26, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 34940, .adv_w = 425, .box_w = 25, .box_h = 26, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 35265, .adv_w = 181, .box_w = 13, .box_h = 5, .ofs_x = -1, .ofs_y = 20} +}; + +/*--------------------- + * CHARACTER MAPPING + *--------------------*/ + +static const uint8_t glyph_id_ofs_list_1[] = { + 0, 0, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 0, + 13, 14, 15, 16, 0, 17, 18, 19, + 0, 0, 0, 20, 0, 21 +}; + +static const uint8_t glyph_id_ofs_list_2[] = { + 0, 0, 1, 0, 2, 3, 4, 0, + 5 +}; + +/*Collect the unicode lists and glyph_id offsets*/ +static const lv_font_fmt_txt_cmap_t cmaps[] = +{ + { + .range_start = 32, .range_length = 95, .glyph_id_start = 1, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 160, .range_length = 30, .glyph_id_start = 96, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_1, .list_length = 30, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 900, .range_length = 9, .glyph_id_start = 118, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_2, .list_length = 9, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 910, .range_length = 20, .glyph_id_start = 124, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 931, .range_length = 44, .glyph_id_start = 144, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 1012, .range_length = 1, .glyph_id_start = 188, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + } +}; + + + +/*-------------------- + * ALL CUSTOM DATA + *--------------------*/ + +#if LVGL_VERSION_MAJOR == 8 +/*Store all the custom data of the font*/ +static lv_font_fmt_txt_glyph_cache_t cache; +#endif + +#if LVGL_VERSION_MAJOR >= 8 +static const lv_font_fmt_txt_dsc_t font_dsc = { +#else +static lv_font_fmt_txt_dsc_t font_dsc = { +#endif + .glyph_bitmap = glyph_bitmap, + .glyph_dsc = glyph_dsc, + .cmaps = cmaps, + .kern_dsc = NULL, + .kern_scale = 0, + .cmap_num = 6, + .bpp = 4, + .kern_classes = 0, + .bitmap_format = 0, +#if LVGL_VERSION_MAJOR == 8 + .cache = &cache +#endif + +}; + +extern const lv_font_t lv_font_montserrat_34; + + +/*----------------- + * PUBLIC FONT + *----------------*/ + +/*Initialize a public general font descriptor*/ +#if LVGL_VERSION_MAJOR >= 8 +const lv_font_t lv_font_arial_34 = { +#else +lv_font_t lv_font_arial_34 = { +#endif + .get_glyph_dsc = lv_font_get_glyph_dsc_fmt_txt, /*Function pointer to get glyph's data*/ + .get_glyph_bitmap = lv_font_get_bitmap_fmt_txt, /*Function pointer to get glyph's bitmap*/ + .line_height = 36, /*The maximum line height required by the font*/ + .base_line = 7, /*Baseline measured from the bottom of the line*/ +#if !(LVGL_VERSION_MAJOR == 6 && LVGL_VERSION_MINOR == 0) + .subpx = LV_FONT_SUBPX_NONE, +#endif +#if LV_VERSION_CHECK(7, 4, 0) || LVGL_VERSION_MAJOR >= 8 + .underline_position = -4, + .underline_thickness = 2, +#endif + //.static_bitmap = 0, + .dsc = &font_dsc, /*The custom font data. Will be accessed by `get_glyph_bitmap/dsc` */ +#if LV_VERSION_CHECK(8, 2, 0) || LVGL_VERSION_MAJOR >= 9 + .fallback = &lv_font_montserrat_34, +#endif + .user_data = NULL, +}; + + + +#endif /*#if LV_FONT_ARIAL_34*/ diff --git a/src/fonts/lv_font_arial_36.c b/src/fonts/lv_font_arial_36.c new file mode 100644 index 0000000000..69f6aca48a --- /dev/null +++ b/src/fonts/lv_font_arial_36.c @@ -0,0 +1,5812 @@ +/******************************************************************************* + * Size: 36 px + * Bpp: 4 + * Opts: --bpp 4 --size 36 --no-compress --stride 1 --align 1 --font Arial Greek Regular.ttf --range 32-127,160-255,880-1023 --format lvgl -o lv_font_arial_36.c + ******************************************************************************/ + +#ifdef __has_include + #if __has_include("lvgl.h") + #ifndef LV_LVGL_H_INCLUDE_SIMPLE + #define LV_LVGL_H_INCLUDE_SIMPLE + #endif + #endif +#endif + +#ifdef LV_LVGL_H_INCLUDE_SIMPLE + #include "lvgl.h" +#else + #include "lvgl/lvgl.h" +#endif + + + +#ifndef LV_FONT_ARIAL_36 +#define LV_FONT_ARIAL_36 1 +#endif + +#if LV_FONT_ARIAL_36 + +/*----------------- + * BITMAPS + *----------------*/ + +/*Store the image of the glyphs*/ +static LV_ATTRIBUTE_LARGE_CONST const uint8_t glyph_bitmap[] = { + /* U+0020 " " */ + + /* U+0021 "!" */ + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xef, 0xfe, 0xdf, 0xfd, + 0xcf, 0xfc, 0xaf, 0xfb, 0x9f, 0xfa, 0x8f, 0xf9, + 0x7f, 0xf8, 0x6f, 0xf7, 0x5f, 0xf5, 0x4f, 0xf4, + 0x2f, 0xf3, 0x1f, 0xf2, 0xf, 0xf1, 0x4, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x79, 0x97, 0xdf, 0xfd, + 0xdf, 0xfd, 0xdf, 0xfd, + + /* U+0022 "\"" */ + 0x5f, 0xff, 0x40, 0x8f, 0xff, 0x15, 0xff, 0xf4, + 0x8, 0xff, 0xf1, 0x5f, 0xff, 0x40, 0x8f, 0xff, + 0x15, 0xff, 0xf4, 0x8, 0xff, 0xf1, 0x4f, 0xff, + 0x30, 0x7f, 0xff, 0x1, 0xff, 0xf1, 0x4, 0xff, + 0xe0, 0xe, 0xfe, 0x0, 0x1f, 0xfb, 0x0, 0xbf, + 0xb0, 0x0, 0xef, 0x80, 0x8, 0xf9, 0x0, 0xb, + 0xf5, 0x0, 0x1, 0x0, 0x0, 0x1, 0x0, + + /* U+0023 "#" */ + 0x0, 0x0, 0x0, 0xd, 0xfd, 0x0, 0x0, 0xa, + 0xff, 0x0, 0x0, 0x0, 0x0, 0xf, 0xf9, 0x0, + 0x0, 0xd, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xf6, 0x0, 0x0, 0x1f, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xf2, 0x0, 0x0, 0x4f, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xf0, 0x0, 0x0, 0x8f, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0xef, 0xb0, 0x0, + 0x0, 0xbf, 0xe0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0x80, 0x0, 0x0, 0xff, 0xb0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x59, 0x99, 0x9e, 0xfe, 0x99, 0x99, + 0x9d, 0xff, 0x99, 0x96, 0x0, 0x0, 0xf, 0xfb, + 0x0, 0x0, 0xc, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xf7, 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xf4, 0x0, 0x0, 0x3f, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf1, 0x0, 0x0, + 0x6f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xe0, + 0x0, 0x0, 0x9f, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xa0, 0x0, 0x0, 0xcf, 0xd0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0x59, 0x9d, 0xff, 0x99, + 0x99, 0x9c, 0xff, 0xa9, 0x99, 0x96, 0x0, 0xc, + 0xfd, 0x0, 0x0, 0x9, 0xff, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xfa, 0x0, 0x0, 0xd, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xf7, 0x0, 0x0, 0xf, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf3, 0x0, + 0x0, 0x3f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xf0, 0x0, 0x0, 0x6f, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xd0, 0x0, 0x0, 0xaf, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0x90, 0x0, 0x0, 0xdf, + 0xc0, 0x0, 0x0, 0x0, + + /* U+0024 "$" */ + 0x0, 0x0, 0x0, 0x0, 0x77, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x17, 0xce, 0xff, 0xeb, + 0x60, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x40, 0x0, 0x0, 0x7f, 0xff, 0xfc, + 0xff, 0xdf, 0xff, 0xf3, 0x0, 0x2, 0xff, 0xfc, + 0x20, 0xfe, 0x5, 0xff, 0xfd, 0x0, 0x9, 0xff, + 0xd0, 0x0, 0xfe, 0x0, 0x5f, 0xff, 0x40, 0xe, + 0xff, 0x50, 0x0, 0xfe, 0x0, 0xd, 0xff, 0x90, + 0xf, 0xff, 0x10, 0x0, 0xfe, 0x0, 0x7, 0xa8, + 0x40, 0x1f, 0xff, 0x20, 0x0, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0x60, 0x0, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xe1, 0x0, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xfe, 0x40, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xfd, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xfc, 0x71, 0x0, 0x0, 0x0, + 0x0, 0x29, 0xff, 0xff, 0xff, 0xfe, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xfe, 0x17, 0xef, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0xfe, 0x0, + 0x1d, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xfe, + 0x0, 0x4, 0xff, 0xf3, 0x0, 0x1, 0x0, 0x0, + 0xfe, 0x0, 0x0, 0xff, 0xf5, 0x6c, 0xfa, 0x0, + 0x0, 0xfe, 0x0, 0x0, 0xdf, 0xf6, 0x7f, 0xfe, + 0x0, 0x0, 0xfe, 0x0, 0x0, 0xff, 0xf4, 0x4f, + 0xff, 0x40, 0x0, 0xfe, 0x0, 0x3, 0xff, 0xf1, + 0xe, 0xff, 0xc0, 0x0, 0xfe, 0x0, 0xc, 0xff, + 0xc0, 0x7, 0xff, 0xfb, 0x10, 0xfe, 0x2, 0xcf, + 0xff, 0x30, 0x0, 0xbf, 0xff, 0xfa, 0xff, 0xbf, + 0xff, 0xf8, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x28, 0xdf, + 0xff, 0xfd, 0x92, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xfe, 0x0, 0x0, 0x0, 0x0, + + /* U+0025 "%" */ + 0x0, 0x19, 0xef, 0xea, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0x10, 0x0, 0x0, 0x2, 0xef, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xf8, 0x0, 0x0, 0x0, 0xd, 0xff, 0x73, 0x5d, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x8f, 0xf1, 0x0, + 0x0, 0x0, 0x5f, 0xf8, 0x0, 0x2, 0xff, 0xa0, + 0x0, 0x0, 0x1, 0xff, 0x80, 0x0, 0x0, 0x0, + 0xaf, 0xf2, 0x0, 0x0, 0xcf, 0xf0, 0x0, 0x0, + 0x9, 0xfe, 0x10, 0x0, 0x0, 0x0, 0xcf, 0xf0, + 0x0, 0x0, 0xaf, 0xf1, 0x0, 0x0, 0x1f, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xe0, 0x0, 0x0, + 0x9f, 0xf2, 0x0, 0x0, 0x9f, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xf0, 0x0, 0x0, 0xaf, 0xf1, + 0x0, 0x2, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xf1, 0x0, 0x0, 0xcf, 0xf0, 0x0, 0xa, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf6, + 0x0, 0x1, 0xff, 0xb0, 0x0, 0x2f, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xfe, 0x40, 0x2c, + 0xff, 0x40, 0x0, 0xbf, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x3, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2b, 0xff, 0xfc, 0x40, 0x0, 0xb, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x10, 0x0, 0x0, 0x4f, 0xf5, 0x0, 0x0, + 0x1, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xc0, 0x0, 0x6, 0xef, 0xff, + 0xb3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0x40, 0x0, 0x9f, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xfc, 0x0, + 0x4, 0xff, 0xc2, 0x4, 0xef, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf3, 0x0, 0xb, 0xff, + 0x20, 0x0, 0x5f, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xb0, 0x0, 0xf, 0xfc, 0x0, 0x0, + 0xf, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0x30, 0x0, 0x1f, 0xfa, 0x0, 0x0, 0xe, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xfa, 0x0, 0x0, + 0x2f, 0xf9, 0x0, 0x0, 0xe, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf2, 0x0, 0x0, 0x1f, 0xfa, + 0x0, 0x0, 0xf, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xa0, 0x0, 0x0, 0xe, 0xfc, 0x0, 0x0, + 0x2f, 0xf9, 0x0, 0x0, 0x0, 0x7, 0xff, 0x20, + 0x0, 0x0, 0xa, 0xff, 0x20, 0x0, 0x8f, 0xf5, + 0x0, 0x0, 0x0, 0x1f, 0xf9, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xd4, 0x27, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x8f, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xfd, 0x20, 0x0, 0x0, 0x1, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x3, 0xbe, 0xfd, + 0x81, 0x0, + + /* U+0026 "&" */ + 0x0, 0x0, 0x0, 0x17, 0xcf, 0xfd, 0x92, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xfb, 0xaf, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xd1, 0x0, + 0x1d, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xf3, 0x0, 0x0, 0x4f, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x10, 0x0, 0x1, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xf4, 0x0, 0x0, 0x4f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xd0, 0x0, 0xb, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xa0, 0xa, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x9d, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xc2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3c, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xdf, + 0xff, 0xa7, 0xff, 0xfd, 0x10, 0x0, 0x20, 0x0, + 0x0, 0x1, 0xdf, 0xff, 0x60, 0x9, 0xff, 0xfb, + 0x0, 0x1f, 0xfc, 0x30, 0x0, 0x9f, 0xff, 0x40, + 0x0, 0xb, 0xff, 0xf8, 0x5, 0xff, 0xf2, 0x0, + 0x1f, 0xff, 0x80, 0x0, 0x0, 0xd, 0xff, 0xf5, + 0xcf, 0xfc, 0x0, 0x5, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x2e, 0xff, 0xff, 0xff, 0x60, 0x0, 0x6f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xe0, 0x0, 0x5, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xf6, 0x0, 0x0, 0x2f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0xcf, 0xff, 0x30, 0x0, 0x0, 0x3, + 0xef, 0xff, 0xff, 0xa0, 0x0, 0x3, 0xff, 0xfe, + 0x50, 0x0, 0x29, 0xff, 0xfe, 0xdf, 0xff, 0xb0, + 0x0, 0x6, 0xff, 0xff, 0xfc, 0xef, 0xff, 0xfe, + 0x22, 0xef, 0xff, 0xd0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xff, 0xfa, 0x10, 0x2, 0xef, 0xf7, 0x0, + 0x0, 0x1, 0x7c, 0xef, 0xec, 0x83, 0x0, 0x0, + 0x1, 0xc9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0027 "'" */ + 0x5f, 0xff, 0x35, 0xff, 0xf3, 0x5f, 0xff, 0x35, + 0xff, 0xf3, 0x5f, 0xff, 0x32, 0xff, 0xf0, 0xf, + 0xfd, 0x0, 0xdf, 0xa0, 0xa, 0xf7, 0x0, 0x1, + 0x0, + + /* U+0028 "(" */ + 0x0, 0x0, 0x0, 0xef, 0x60, 0x0, 0x0, 0xaf, + 0xc0, 0x0, 0x0, 0x5f, 0xf3, 0x0, 0x0, 0xe, + 0xfb, 0x0, 0x0, 0x8, 0xff, 0x30, 0x0, 0x1, + 0xff, 0xc0, 0x0, 0x0, 0x8f, 0xf5, 0x0, 0x0, + 0xe, 0xff, 0x0, 0x0, 0x5, 0xff, 0xa0, 0x0, + 0x0, 0xbf, 0xf6, 0x0, 0x0, 0xf, 0xff, 0x20, + 0x0, 0x3, 0xff, 0xe0, 0x0, 0x0, 0x7f, 0xfc, + 0x0, 0x0, 0x9, 0xff, 0xa0, 0x0, 0x0, 0xbf, + 0xf8, 0x0, 0x0, 0xc, 0xff, 0x70, 0x0, 0x0, + 0xcf, 0xf7, 0x0, 0x0, 0xc, 0xff, 0x70, 0x0, + 0x0, 0xbf, 0xf8, 0x0, 0x0, 0x9, 0xff, 0xa0, + 0x0, 0x0, 0x7f, 0xfc, 0x0, 0x0, 0x3, 0xff, + 0xe0, 0x0, 0x0, 0xf, 0xff, 0x20, 0x0, 0x0, + 0xbf, 0xf6, 0x0, 0x0, 0x6, 0xff, 0xa0, 0x0, + 0x0, 0xf, 0xff, 0x0, 0x0, 0x0, 0x9f, 0xf6, + 0x0, 0x0, 0x1, 0xff, 0xc0, 0x0, 0x0, 0x8, + 0xff, 0x30, 0x0, 0x0, 0x1e, 0xfb, 0x0, 0x0, + 0x0, 0x5f, 0xf3, 0x0, 0x0, 0x0, 0xaf, 0xc0, + 0x0, 0x0, 0x1, 0xef, 0x60, + + /* U+0029 ")" */ + 0x6f, 0xd0, 0x0, 0x0, 0x0, 0xcf, 0xa0, 0x0, + 0x0, 0x3, 0xff, 0x50, 0x0, 0x0, 0xb, 0xfe, + 0x0, 0x0, 0x0, 0x3f, 0xf8, 0x0, 0x0, 0x0, + 0xcf, 0xf1, 0x0, 0x0, 0x6, 0xff, 0x80, 0x0, + 0x0, 0xf, 0xfe, 0x0, 0x0, 0x0, 0xaf, 0xf5, + 0x0, 0x0, 0x6, 0xff, 0xa0, 0x0, 0x0, 0x2f, + 0xff, 0x0, 0x0, 0x0, 0xef, 0xf3, 0x0, 0x0, + 0xc, 0xff, 0x70, 0x0, 0x0, 0xaf, 0xf9, 0x0, + 0x0, 0x8, 0xff, 0xb0, 0x0, 0x0, 0x7f, 0xfc, + 0x0, 0x0, 0x7, 0xff, 0xc0, 0x0, 0x0, 0x7f, + 0xfc, 0x0, 0x0, 0x8, 0xff, 0xb0, 0x0, 0x0, + 0xaf, 0xf9, 0x0, 0x0, 0xc, 0xff, 0x70, 0x0, + 0x0, 0xff, 0xf4, 0x0, 0x0, 0x2f, 0xff, 0x0, + 0x0, 0x6, 0xff, 0xb0, 0x0, 0x0, 0xbf, 0xf5, + 0x0, 0x0, 0x1f, 0xfe, 0x0, 0x0, 0x6, 0xff, + 0x80, 0x0, 0x0, 0xcf, 0xf1, 0x0, 0x0, 0x3f, + 0xf8, 0x0, 0x0, 0xb, 0xfe, 0x0, 0x0, 0x3, + 0xff, 0x50, 0x0, 0x0, 0xcf, 0xa0, 0x0, 0x0, + 0x6f, 0xd1, 0x0, 0x0, 0x0, + + /* U+002A "*" */ + 0x0, 0x0, 0x4f, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xf2, 0x0, 0x0, 0x2, 0x0, 0x1f, 0xf1, + 0x0, 0x20, 0x4f, 0xc6, 0x1f, 0xf0, 0x6c, 0xf4, + 0x9f, 0xff, 0xef, 0xfe, 0xff, 0xf9, 0x37, 0xbe, + 0xff, 0xff, 0xfc, 0x83, 0x0, 0x1, 0xdf, 0xfd, + 0x0, 0x0, 0x0, 0xc, 0xfc, 0xdf, 0xc0, 0x0, + 0x0, 0xaf, 0xf3, 0x3f, 0xfa, 0x0, 0x2, 0xff, + 0x90, 0x9, 0xff, 0x30, 0x0, 0x2a, 0x10, 0x0, + 0xa2, 0x0, + + /* U+002B "+" */ + 0x0, 0x0, 0x0, 0xf, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x0, 0x0, 0x0, + 0x0, + + /* U+002C "," */ + 0x8, 0x99, 0x60, 0xef, 0xfb, 0xe, 0xff, 0xb0, + 0xef, 0xfb, 0x0, 0x2f, 0xa0, 0x4, 0xf9, 0x0, + 0xbf, 0x40, 0xaf, 0xb0, 0x9, 0xa0, 0x0, 0x0, + 0x0, + + /* U+002D "-" */ + 0x22, 0x22, 0x22, 0x22, 0x22, 0xdf, 0xff, 0xff, + 0xff, 0xfd, 0xdf, 0xff, 0xff, 0xff, 0xfd, 0xdf, + 0xff, 0xff, 0xff, 0xfd, + + /* U+002E "." */ + 0x79, 0x97, 0xcf, 0xfc, 0xcf, 0xfc, 0xcf, 0xfc, + + /* U+002F "/" */ + 0x0, 0x0, 0x0, 0xa, 0xfd, 0x0, 0x0, 0x0, + 0xf, 0xf9, 0x0, 0x0, 0x0, 0x4f, 0xf4, 0x0, + 0x0, 0x0, 0x8f, 0xf0, 0x0, 0x0, 0x0, 0xdf, + 0xb0, 0x0, 0x0, 0x1, 0xff, 0x60, 0x0, 0x0, + 0x6, 0xff, 0x20, 0x0, 0x0, 0xb, 0xfd, 0x0, + 0x0, 0x0, 0xf, 0xf8, 0x0, 0x0, 0x0, 0x4f, + 0xf4, 0x0, 0x0, 0x0, 0x8f, 0xf0, 0x0, 0x0, + 0x0, 0xdf, 0xb0, 0x0, 0x0, 0x1, 0xff, 0x60, + 0x0, 0x0, 0x6, 0xff, 0x20, 0x0, 0x0, 0xb, + 0xfd, 0x0, 0x0, 0x0, 0xf, 0xf8, 0x0, 0x0, + 0x0, 0x4f, 0xf4, 0x0, 0x0, 0x0, 0x8f, 0xf0, + 0x0, 0x0, 0x0, 0xdf, 0xb0, 0x0, 0x0, 0x2, + 0xff, 0x60, 0x0, 0x0, 0x6, 0xff, 0x10, 0x0, + 0x0, 0xb, 0xfd, 0x0, 0x0, 0x0, 0xf, 0xf8, + 0x0, 0x0, 0x0, 0x4f, 0xf4, 0x0, 0x0, 0x0, + 0x9f, 0xf0, 0x0, 0x0, 0x0, 0xdf, 0xb0, 0x0, + 0x0, 0x0, + + /* U+0030 "0" */ + 0x0, 0x0, 0x3, 0x9d, 0xff, 0xd9, 0x30, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xfd, 0xaa, 0xef, + 0xff, 0xa0, 0x0, 0x0, 0x7f, 0xff, 0x60, 0x0, + 0x7, 0xff, 0xf6, 0x0, 0x0, 0xef, 0xf7, 0x0, + 0x0, 0x0, 0x8f, 0xfd, 0x0, 0x6, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0x40, 0xa, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x9, 0xff, 0x90, 0xe, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x5, 0xff, 0xd0, + 0x1f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xf0, 0x3f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf2, 0x5f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf4, 0x6f, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xf4, 0x6f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xf5, 0x6f, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xf5, 0x6f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf4, 0x5f, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf4, + 0x3f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf2, 0x1f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf0, 0xe, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xd0, 0xa, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x9, 0xff, 0x90, 0x6, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0x50, 0x0, 0xef, 0xf7, + 0x0, 0x0, 0x0, 0x8f, 0xfe, 0x0, 0x0, 0x7f, + 0xff, 0x60, 0x0, 0x7, 0xff, 0xf6, 0x0, 0x0, + 0xb, 0xff, 0xfd, 0xaa, 0xef, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x3, 0x9d, 0xff, 0xd9, 0x30, + 0x0, 0x0, + + /* U+0031 "1" */ + 0x0, 0x0, 0x0, 0x0, 0xdf, 0x70, 0x0, 0x0, + 0x0, 0x8f, 0xf7, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x70, 0x0, 0x0, 0x6f, 0xff, 0xf7, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0x70, 0x5, 0xdf, 0xff, 0xff, + 0xf7, 0xc, 0xff, 0xff, 0x7b, 0xff, 0x70, 0xff, + 0xfd, 0x30, 0xbf, 0xf7, 0xf, 0xe6, 0x0, 0xb, + 0xff, 0x70, 0x50, 0x0, 0x0, 0xbf, 0xf7, 0x0, + 0x0, 0x0, 0xb, 0xff, 0x70, 0x0, 0x0, 0x0, + 0xbf, 0xf7, 0x0, 0x0, 0x0, 0xb, 0xff, 0x70, + 0x0, 0x0, 0x0, 0xbf, 0xf7, 0x0, 0x0, 0x0, + 0xb, 0xff, 0x70, 0x0, 0x0, 0x0, 0xbf, 0xf7, + 0x0, 0x0, 0x0, 0xb, 0xff, 0x70, 0x0, 0x0, + 0x0, 0xbf, 0xf7, 0x0, 0x0, 0x0, 0xb, 0xff, + 0x70, 0x0, 0x0, 0x0, 0xbf, 0xf7, 0x0, 0x0, + 0x0, 0xb, 0xff, 0x70, 0x0, 0x0, 0x0, 0xbf, + 0xf7, 0x0, 0x0, 0x0, 0xb, 0xff, 0x70, 0x0, + 0x0, 0x0, 0xbf, 0xf7, 0x0, 0x0, 0x0, 0xb, + 0xff, 0x70, 0x0, 0x0, 0x0, 0xbf, 0xf7, + + /* U+0032 "2" */ + 0x0, 0x0, 0x5, 0xad, 0xff, 0xeb, 0x60, 0x0, + 0x0, 0x0, 0x4, 0xef, 0xff, 0xff, 0xff, 0xfe, + 0x40, 0x0, 0x0, 0x5f, 0xff, 0xfd, 0xaa, 0xcf, + 0xff, 0xf5, 0x0, 0x1, 0xff, 0xfd, 0x30, 0x0, + 0x3, 0xdf, 0xff, 0x10, 0x9, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0x90, 0xe, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xe0, 0x2f, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf0, 0x19, + 0xac, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xef, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1d, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xdf, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2e, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xfe, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf2, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf2, + + /* U+0033 "3" */ + 0x0, 0x0, 0x6, 0xbe, 0xfe, 0xc8, 0x20, 0x0, + 0x0, 0x0, 0x4, 0xef, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfb, 0x9a, 0xef, + 0xff, 0x90, 0x0, 0x1, 0xef, 0xfc, 0x10, 0x0, + 0x8, 0xff, 0xf5, 0x0, 0x7, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x9f, 0xfd, 0x0, 0xd, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x10, 0x9, 0xcf, + 0x20, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x5, 0x7a, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xff, 0xb1, 0x0, 0x0, 0x0, 0x0, + 0x3, 0x0, 0x39, 0xff, 0xfd, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf6, 0x15, 0x88, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf6, 0x4f, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xf4, 0x1f, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xf0, 0xa, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x90, 0x2, 0xff, + 0xfd, 0x20, 0x0, 0x5, 0xff, 0xfe, 0x10, 0x0, + 0x5f, 0xff, 0xfc, 0xaa, 0xef, 0xff, 0xe2, 0x0, + 0x0, 0x4, 0xef, 0xff, 0xff, 0xff, 0xfb, 0x10, + 0x0, 0x0, 0x0, 0x6, 0xbe, 0xff, 0xd9, 0x30, + 0x0, 0x0, + + /* U+0034 "4" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xcf, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xc4, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf2, + 0x4f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xf6, 0x4, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xfb, 0x0, 0x4f, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0x10, 0x4, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0x60, 0x0, 0x4f, 0xfe, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xb0, 0x0, 0x4, + 0xff, 0xe0, 0x0, 0x0, 0x1, 0xef, 0xe1, 0x0, + 0x0, 0x4f, 0xfe, 0x0, 0x0, 0x0, 0xbf, 0xf5, + 0x0, 0x0, 0x4, 0xff, 0xe0, 0x0, 0x0, 0x6f, + 0xfa, 0x0, 0x0, 0x0, 0x4f, 0xfe, 0x0, 0x0, + 0x2f, 0xfe, 0x10, 0x0, 0x0, 0x4, 0xff, 0xe0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf5, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x56, 0xee, 0xee, 0xee, + 0xee, 0xee, 0xef, 0xff, 0xee, 0xe5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xfe, 0x0, 0x0, + + /* U+0035 "5" */ + 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x70, 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x70, 0x0, 0xd, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x70, 0x0, 0xf, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf0, 0x17, 0xac, 0xb8, 0x30, 0x0, + 0x0, 0x2, 0xff, 0xe9, 0xff, 0xff, 0xff, 0xfc, + 0x20, 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x9, 0xff, 0xfe, 0x72, 0x1, + 0x4a, 0xff, 0xfe, 0x20, 0xc, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xa0, 0x2, 0x57, 0x20, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf9, 0x26, 0x78, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xf7, 0x4f, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xf3, 0x1f, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xe0, 0xb, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x70, 0x3, 0xff, + 0xfd, 0x30, 0x0, 0x5, 0xff, 0xfc, 0x0, 0x0, + 0x6f, 0xff, 0xfc, 0x9a, 0xdf, 0xff, 0xd2, 0x0, + 0x0, 0x4, 0xef, 0xff, 0xff, 0xff, 0xfb, 0x10, + 0x0, 0x0, 0x0, 0x6, 0xbe, 0xff, 0xd9, 0x40, + 0x0, 0x0, + + /* U+0036 "6" */ + 0x0, 0x0, 0x0, 0x6b, 0xef, 0xfc, 0x82, 0x0, + 0x0, 0x0, 0x0, 0x4d, 0xff, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x4, 0xff, 0xff, 0xba, 0xbf, + 0xff, 0xf7, 0x0, 0x0, 0x2f, 0xff, 0xa1, 0x0, + 0x1, 0xbf, 0xff, 0x20, 0x0, 0xbf, 0xfb, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0x90, 0x3, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xe0, 0x8, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x1, 0x87, 0x50, 0xd, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xfd, 0x0, 0x39, 0xdf, 0xfd, 0x81, + 0x0, 0x0, 0x5f, 0xfb, 0x8, 0xff, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x6f, 0xfa, 0x9f, 0xff, 0xdc, + 0xef, 0xff, 0xf6, 0x0, 0x7f, 0xfe, 0xff, 0x91, + 0x0, 0x4, 0xef, 0xff, 0x30, 0x7f, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xb0, 0x7f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf1, 0x6f, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf5, + 0x5f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xf7, 0x3f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf7, 0xf, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xf6, 0xd, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf4, 0x7, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xf0, 0x1, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0x90, 0x0, 0x6f, + 0xff, 0x80, 0x0, 0x2, 0xdf, 0xfe, 0x10, 0x0, + 0x9, 0xff, 0xff, 0xb9, 0xbf, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xfe, 0x40, + 0x0, 0x0, 0x0, 0x1, 0x7c, 0xef, 0xec, 0x70, + 0x0, 0x0, + + /* U+0037 "7" */ + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf7, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf7, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0038 "8" */ + 0x0, 0x0, 0x4, 0xae, 0xff, 0xda, 0x40, 0x0, + 0x0, 0x0, 0x1, 0xcf, 0xff, 0xff, 0xff, 0xfb, + 0x10, 0x0, 0x0, 0x1d, 0xff, 0xfd, 0xaa, 0xdf, + 0xff, 0xd1, 0x0, 0x0, 0xaf, 0xff, 0x50, 0x0, + 0x6, 0xff, 0xfa, 0x0, 0x1, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x10, 0x5, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x50, 0x6, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0xd, 0xff, 0x60, 0x4, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0xe, 0xff, 0x50, + 0x1, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x10, 0x0, 0x9f, 0xff, 0x40, 0x0, 0x4, 0xff, + 0xf9, 0x0, 0x0, 0xa, 0xff, 0xfd, 0x99, 0xcf, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x5e, 0xff, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x7, 0xef, 0xff, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0xbf, 0xff, + 0x93, 0x0, 0x39, 0xff, 0xfb, 0x0, 0x7, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x70, 0xe, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf0, + 0x4f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf4, 0x6f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xf7, 0x7f, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xf7, 0x5f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf6, 0x2f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf2, 0xc, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xd0, 0x3, 0xff, + 0xfd, 0x30, 0x0, 0x2, 0xcf, 0xff, 0x40, 0x0, + 0x6f, 0xff, 0xfd, 0xaa, 0xcf, 0xff, 0xf6, 0x0, + 0x0, 0x4, 0xef, 0xff, 0xff, 0xff, 0xfe, 0x40, + 0x0, 0x0, 0x0, 0x5, 0xae, 0xff, 0xea, 0x50, + 0x0, 0x0, + + /* U+0039 "9" */ + 0x0, 0x0, 0x6, 0xbe, 0xfe, 0xc7, 0x10, 0x0, + 0x0, 0x0, 0x3, 0xef, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfd, 0xaa, 0xdf, + 0xff, 0xa0, 0x0, 0x1, 0xef, 0xff, 0x50, 0x0, + 0x5, 0xff, 0xf8, 0x0, 0x8, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0x20, 0xf, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x9, 0xff, 0x80, 0x3f, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x4, 0xff, 0xd0, 0x5f, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf1, + 0x6f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf4, 0x5f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xf6, 0x3f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf7, 0xf, 0xff, 0x80, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf7, 0x9, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xf8, 0x1, 0xef, 0xff, + 0x93, 0x0, 0x3a, 0xff, 0xdf, 0xf7, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xff, 0xf7, 0xaf, 0xf7, 0x0, + 0x2, 0xcf, 0xff, 0xff, 0xfe, 0x40, 0xbf, 0xf5, + 0x0, 0x0, 0x4, 0x9b, 0xb9, 0x50, 0x0, 0xdf, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xe0, 0x7, 0x9a, 0x10, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xa0, 0xc, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x40, 0x7, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0xbf, 0xfc, 0x0, 0x1, 0xff, + 0xfa, 0x0, 0x0, 0x1b, 0xff, 0xf3, 0x0, 0x0, + 0x6f, 0xff, 0xea, 0x9b, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xd4, 0x0, + 0x0, 0x0, 0x0, 0x18, 0xcf, 0xfe, 0xb6, 0x0, + 0x0, 0x0, + + /* U+003A ":" */ + 0xcf, 0xfc, 0xcf, 0xfc, 0xcf, 0xfc, 0x79, 0x97, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x97, + 0xcf, 0xfc, 0xcf, 0xfc, 0xcf, 0xfc, + + /* U+003B ";" */ + 0xe, 0xff, 0xb0, 0xef, 0xfb, 0xe, 0xff, 0xb0, + 0x89, 0x96, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x89, 0x96, + 0xe, 0xff, 0xb0, 0xef, 0xfb, 0xe, 0xff, 0xb0, + 0x2, 0xfa, 0x0, 0x4f, 0x90, 0xb, 0xf4, 0xa, + 0xfb, 0x0, 0x9a, 0x0, 0x0, 0x0, 0x0, + + /* U+003C "<" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4a, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xdf, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x2, 0x9f, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x4b, 0xff, 0xff, 0xfd, 0x71, 0x0, + 0x0, 0x0, 0x17, 0xef, 0xff, 0xff, 0xa4, 0x0, + 0x0, 0x0, 0x3, 0xaf, 0xff, 0xff, 0xe7, 0x10, + 0x0, 0x0, 0x0, 0x5c, 0xff, 0xff, 0xfb, 0x40, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xfe, 0x81, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfe, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xd7, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xdf, 0xff, 0xff, 0x93, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4b, 0xff, 0xff, 0xfc, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x8e, + 0xff, 0xff, 0xe8, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xdf, 0xff, 0xff, 0xb4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4a, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x8e, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xc1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+003D "=" */ + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf0, + + /* U+003E ">" */ + 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xfb, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xd6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x92, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x6d, + 0xff, 0xff, 0xfc, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xaf, 0xff, 0xff, 0xe7, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x17, 0xdf, 0xff, 0xff, + 0xa3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4b, + 0xff, 0xff, 0xfc, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x8e, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4e, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xdf, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x3, 0x9f, 0xff, 0xff, + 0xd7, 0x10, 0x0, 0x0, 0x0, 0x5c, 0xff, 0xff, + 0xfb, 0x40, 0x0, 0x0, 0x0, 0x28, 0xef, 0xff, + 0xff, 0x92, 0x0, 0x0, 0x0, 0x4, 0xbf, 0xff, + 0xff, 0xd6, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xfb, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xfe, 0x82, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+003F "?" */ + 0x0, 0x0, 0x5, 0xae, 0xff, 0xeb, 0x60, 0x0, + 0x0, 0x0, 0x4, 0xef, 0xff, 0xff, 0xff, 0xfe, + 0x50, 0x0, 0x0, 0x4f, 0xff, 0xfd, 0xaa, 0xcf, + 0xff, 0xf6, 0x0, 0x1, 0xff, 0xfe, 0x30, 0x0, + 0x3, 0xdf, 0xff, 0x30, 0x9, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xc0, 0xe, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf1, 0x2f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf3, 0x27, + 0x9b, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xbb, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0x99, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xc0, 0x0, + 0x0, 0x0, + + /* U+0040 "@" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x7a, 0xce, + 0xff, 0xed, 0xc8, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x91, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xef, 0xff, + 0xff, 0xca, 0x99, 0xab, 0xef, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xf9, 0x30, 0x0, 0x0, 0x0, 0x2, 0x7e, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf9, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xfe, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xdf, 0xfb, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1d, 0xff, 0x60, 0x0, 0x0, + 0x1f, 0xff, 0x20, 0x0, 0x0, 0x18, 0xdf, 0xeb, + 0x50, 0x5, 0xff, 0xc0, 0x1, 0xef, 0xf1, 0x0, + 0x0, 0xaf, 0xf5, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xff, 0xfa, 0x8, 0xff, 0x90, 0x0, 0x6f, 0xf7, + 0x0, 0x2, 0xff, 0xb0, 0x0, 0x0, 0x8f, 0xff, + 0xeb, 0xad, 0xff, 0x9b, 0xff, 0x60, 0x0, 0xe, + 0xfd, 0x0, 0x9, 0xff, 0x20, 0x0, 0x6, 0xff, + 0xf8, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x20, 0x0, + 0x9, 0xff, 0x10, 0xf, 0xfb, 0x0, 0x0, 0x2f, + 0xff, 0x70, 0x0, 0x0, 0xa, 0xff, 0xff, 0x0, + 0x0, 0x5, 0xff, 0x40, 0x4f, 0xf5, 0x0, 0x0, + 0xcf, 0xfc, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfc, + 0x0, 0x0, 0x3, 0xff, 0x60, 0x8f, 0xf1, 0x0, + 0x3, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xf8, 0x0, 0x0, 0x2, 0xff, 0x70, 0xbf, 0xd0, + 0x0, 0xa, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xf5, 0x0, 0x0, 0x3, 0xff, 0x60, 0xdf, + 0xb0, 0x0, 0xe, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xf2, 0x0, 0x0, 0x5, 0xff, 0x40, + 0xef, 0xa0, 0x0, 0x1f, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xe0, 0x0, 0x0, 0x9, 0xff, + 0x10, 0xff, 0xa0, 0x0, 0x3f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xb0, 0x0, 0x0, 0xe, + 0xfd, 0x0, 0xef, 0xb0, 0x0, 0x3f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0x80, 0x0, 0x0, + 0x6f, 0xf7, 0x0, 0xdf, 0xc0, 0x0, 0x2f, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x40, 0x0, + 0x1, 0xef, 0xe0, 0x0, 0xbf, 0xf0, 0x0, 0xf, + 0xff, 0x40, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x10, + 0x0, 0xb, 0xff, 0x60, 0x0, 0x8f, 0xf3, 0x0, + 0xb, 0xff, 0xb0, 0x0, 0x0, 0x8, 0xff, 0xfe, + 0x0, 0x0, 0xbf, 0xfa, 0x0, 0x0, 0x4f, 0xf9, + 0x0, 0x4, 0xff, 0xf8, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0x20, 0x5e, 0xff, 0xc0, 0x0, 0x0, 0xe, + 0xff, 0x10, 0x0, 0x9f, 0xff, 0xd9, 0xaf, 0xfe, + 0x9f, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x7, 0xff, 0x80, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xd2, 0x2f, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xf4, 0x0, 0x0, 0x5b, 0xff, + 0xc6, 0x0, 0x4, 0xcf, 0xec, 0x82, 0x0, 0x0, + 0x56, 0x61, 0x0, 0x5f, 0xfe, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xc0, 0x0, 0x8, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xbf, 0xfd, 0x10, 0x0, 0x0, 0x9f, 0xff, + 0xb3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xd2, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xd7, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x4, 0x9f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3c, 0xff, 0xff, 0xff, 0xdb, 0xa9, 0x9a, + 0xbd, 0xff, 0xff, 0xfe, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4a, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x8b, 0xde, + 0xff, 0xfe, 0xdb, 0x96, 0x10, 0x0, 0x0, 0x0, + 0x0, + + /* U+0041 "A" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0x9f, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x3c, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfe, 0x7, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf9, 0x1, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf4, 0x0, 0xcf, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xe0, 0x0, 0x6f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0x80, 0x0, 0xf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x30, + 0x0, 0xa, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xfd, 0x0, 0x0, 0x4, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xf7, 0x0, 0x0, 0x0, 0xdf, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xdc, + 0xcc, 0xcc, 0xcc, 0xcf, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0x10, 0x0, 0x0, + 0x8, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x70, 0x0, 0x0, 0xe, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xd0, + 0x0, 0x0, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf4, 0x0, 0x0, 0xaf, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xfa, 0x0, 0x1, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x10, + 0x7, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x70, 0xd, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xe0, + + /* U+0042 "B" */ + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xda, 0x50, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe4, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x5, + 0xff, 0xf1, 0x0, 0x0, 0x1, 0x25, 0xaf, 0xff, + 0xf1, 0x0, 0x5f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x70, 0x5, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfb, 0x0, 0x5f, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xd0, 0x5, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xfc, 0x0, 0x5f, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0x90, 0x5, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf2, + 0x0, 0x5f, 0xff, 0x10, 0x0, 0x0, 0x1, 0x49, + 0xff, 0xf7, 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x40, 0x0, + 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x5f, 0xff, 0x10, 0x0, 0x0, + 0x1, 0x37, 0xdf, 0xff, 0xc0, 0x5, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x60, + 0x5f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xfc, 0x5, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xf0, 0x5f, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x15, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xf0, 0x5f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xfd, 0x5, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x80, 0x5f, + 0xff, 0x10, 0x0, 0x0, 0x1, 0x26, 0xcf, 0xff, + 0xe1, 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd3, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0xc8, 0x40, 0x0, + 0x0, + + /* U+0043 "C" */ + 0x0, 0x0, 0x0, 0x0, 0x48, 0xcd, 0xff, 0xeb, + 0x82, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5d, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xa1, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xfe, 0xff, + 0xff, 0xfe, 0x30, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xf8, 0x30, 0x0, 0x4, 0xbf, 0xff, 0xf2, 0x0, + 0x0, 0xa, 0xff, 0xfa, 0x10, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xfd, 0x0, 0x0, 0x5f, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x70, + 0x0, 0xdf, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xd0, 0x4, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xfb, 0x80, + 0x9, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x20, 0x0, 0x8, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xb4, + 0x3, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf5, 0x0, 0xcf, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xe0, + 0x0, 0x4f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0x70, 0x0, 0xa, 0xff, 0xfa, + 0x10, 0x0, 0x0, 0x0, 0x8, 0xff, 0xfd, 0x0, + 0x0, 0x1, 0xdf, 0xff, 0xe7, 0x20, 0x0, 0x16, + 0xdf, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x1d, 0xff, + 0xff, 0xff, 0xef, 0xff, 0xff, 0xfe, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xa1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x59, 0xce, 0xff, 0xeb, 0x71, 0x0, 0x0, 0x0, + + /* U+0044 "D" */ + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdb, 0x84, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x30, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x2, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x13, 0x7c, 0xff, 0xff, 0x30, 0x0, 0x2f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfe, + 0x10, 0x2, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xf8, 0x0, 0x2f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf1, + 0x2, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x50, 0x2f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf9, 0x2, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xd0, 0x2f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x2, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf0, 0x2f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x12, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xf1, 0x2f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x2, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf0, + 0x2f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xfc, 0x2, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x90, 0x2f, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf5, 0x2, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xfe, 0x0, 0x2f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0x70, 0x2, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x2f, 0xff, 0x40, + 0x0, 0x0, 0x1, 0x37, 0xdf, 0xff, 0xf3, 0x0, + 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb2, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xa7, 0x20, + 0x0, 0x0, 0x0, + + /* U+0045 "E" */ + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf7, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x70, 0x2f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x2, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x2f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x2f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf1, 0x2f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x12, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf1, + + /* U+0046 "F" */ + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x41, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf4, 0x1f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x41, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x60, 0x1, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf6, 0x0, 0x1f, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0047 "G" */ + 0x0, 0x0, 0x0, 0x0, 0x26, 0xad, 0xef, 0xfe, + 0xc9, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd5, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xfe, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xb5, 0x10, 0x0, 0x3, 0x8f, 0xff, + 0xf7, 0x0, 0x0, 0x6, 0xff, 0xfd, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x1c, 0xff, 0xf3, 0x0, 0x2, + 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1d, 0xff, 0xb0, 0x0, 0xaf, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x10, + 0x2f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc9, 0x50, 0x7, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb1, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb0, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfb, + 0xc, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xb0, 0x7f, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xfb, 0x2, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xb0, 0xa, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xfb, 0x0, 0x2f, 0xff, 0xe3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, 0xb0, 0x0, + 0x5f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xaf, 0xff, 0xfb, 0x0, 0x0, 0x7f, 0xff, 0xfe, + 0x94, 0x21, 0x23, 0x6c, 0xff, 0xff, 0xfc, 0x20, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x19, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x81, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x59, 0xce, 0xff, + 0xec, 0x95, 0x0, 0x0, 0x0, + + /* U+0048 "H" */ + 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf1, 0x1f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf1, 0x1f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xf1, 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf1, 0x1f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf1, 0x1f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf1, 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xf1, 0x1f, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf1, + 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf1, 0x1f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf1, 0x1f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xf1, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf1, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0x1f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf1, 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xf1, 0x1f, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf1, + 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf1, 0x1f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf1, 0x1f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xf1, 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf1, 0x1f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf1, 0x1f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf1, 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xf1, 0x1f, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf1, + 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf1, 0x1f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf1, + + /* U+0049 "I" */ + 0xbf, 0xfb, 0xbf, 0xfb, 0xbf, 0xfb, 0xbf, 0xfb, + 0xbf, 0xfb, 0xbf, 0xfb, 0xbf, 0xfb, 0xbf, 0xfb, + 0xbf, 0xfb, 0xbf, 0xfb, 0xbf, 0xfb, 0xbf, 0xfb, + 0xbf, 0xfb, 0xbf, 0xfb, 0xbf, 0xfb, 0xbf, 0xfb, + 0xbf, 0xfb, 0xbf, 0xfb, 0xbf, 0xfb, 0xbf, 0xfb, + 0xbf, 0xfb, 0xbf, 0xfb, 0xbf, 0xfb, 0xbf, 0xfb, + 0xbf, 0xfb, 0xbf, 0xfb, + + /* U+004A "J" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf3, + 0xb, 0xef, 0x20, 0x0, 0x0, 0x3, 0xff, 0xf2, + 0xe, 0xff, 0x40, 0x0, 0x0, 0x5, 0xff, 0xf1, + 0xc, 0xff, 0x80, 0x0, 0x0, 0x8, 0xff, 0xe0, + 0x9, 0xff, 0xe1, 0x0, 0x0, 0xe, 0xff, 0xb0, + 0x3, 0xff, 0xfd, 0x41, 0x14, 0xcf, 0xff, 0x50, + 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x4a, 0xef, 0xfd, 0xa3, 0x0, 0x0, + + /* U+004B "K" */ + 0x5f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xd1, 0x5f, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xfd, 0x10, 0x5f, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xd1, + 0x0, 0x5f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xfc, 0x10, 0x0, 0x5f, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xc1, 0x0, 0x0, 0x5f, + 0xff, 0x10, 0x0, 0x0, 0x9, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x10, 0x0, 0x0, 0x9f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x10, + 0x0, 0x9, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x10, 0x0, 0x9f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x10, 0x9, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x10, 0x8f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x18, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x9f, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xf9, 0x4f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0x90, 0x9, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf9, + 0x0, 0x0, 0xdf, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x80, 0x0, 0x0, 0x3f, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x10, 0x0, 0x0, + 0x7, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x10, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x70, 0x0, + 0x0, 0x5f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xf3, 0x0, 0x0, 0x5f, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xfe, 0x10, 0x0, 0x5f, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xa0, 0x0, 0x5f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xf6, 0x0, 0x5f, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x20, + 0x5f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xd0, 0x5f, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf9, + + /* U+004C "L" */ + 0x4f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x4f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd4, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfd, + + /* U+004D "M" */ + 0x4f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xf4, 0x4f, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xf4, 0x4f, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf4, 0x4f, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf4, 0x4f, 0xff, 0xcf, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xfe, 0xff, + 0xf4, 0x4f, 0xff, 0x7f, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xf9, 0xff, 0xf4, 0x4f, 0xff, + 0x1f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xf3, 0xff, 0xf4, 0x4f, 0xff, 0xc, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xe0, 0xff, 0xf4, + 0x4f, 0xff, 0x7, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0x80, 0xff, 0xf4, 0x4f, 0xff, 0x1, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x30, + 0xff, 0xf4, 0x4f, 0xff, 0x0, 0xcf, 0xf5, 0x0, + 0x0, 0x0, 0xd, 0xfd, 0x0, 0xff, 0xf4, 0x4f, + 0xff, 0x0, 0x6f, 0xfa, 0x0, 0x0, 0x0, 0x3f, + 0xf8, 0x0, 0xff, 0xf4, 0x4f, 0xff, 0x0, 0x1f, + 0xff, 0x0, 0x0, 0x0, 0x8f, 0xf2, 0x0, 0xff, + 0xf4, 0x4f, 0xff, 0x0, 0xc, 0xff, 0x40, 0x0, + 0x0, 0xef, 0xd0, 0x0, 0xff, 0xf4, 0x4f, 0xff, + 0x0, 0x6, 0xff, 0xa0, 0x0, 0x3, 0xff, 0x70, + 0x0, 0xff, 0xf4, 0x4f, 0xff, 0x0, 0x1, 0xff, + 0xf0, 0x0, 0x9, 0xff, 0x20, 0x0, 0xff, 0xf4, + 0x4f, 0xff, 0x0, 0x0, 0xbf, 0xf4, 0x0, 0xe, + 0xfc, 0x0, 0x0, 0xff, 0xf4, 0x4f, 0xff, 0x0, + 0x0, 0x6f, 0xfa, 0x0, 0x4f, 0xf7, 0x0, 0x0, + 0xff, 0xf4, 0x4f, 0xff, 0x0, 0x0, 0x1f, 0xff, + 0x0, 0x9f, 0xf1, 0x0, 0x0, 0xff, 0xf4, 0x4f, + 0xff, 0x0, 0x0, 0xb, 0xff, 0x40, 0xef, 0xc0, + 0x0, 0x0, 0xff, 0xf4, 0x4f, 0xff, 0x0, 0x0, + 0x6, 0xff, 0x94, 0xff, 0x60, 0x0, 0x0, 0xff, + 0xf4, 0x4f, 0xff, 0x0, 0x0, 0x1, 0xff, 0xe9, + 0xff, 0x10, 0x0, 0x0, 0xff, 0xf4, 0x4f, 0xff, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0xff, 0xf4, 0x4f, 0xff, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0xff, 0xf4, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0xff, 0xf4, 0x4f, 0xff, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0xff, 0xf4, + + /* U+004E "N" */ + 0x2f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf2, 0x2f, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf2, 0x2f, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xf2, 0x2f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xf2, 0x2f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf2, 0x2f, + 0xff, 0xef, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf2, 0x2f, 0xff, 0x6f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xf2, 0x2f, 0xff, 0x29, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf2, + 0x2f, 0xff, 0x20, 0xef, 0xfe, 0x10, 0x0, 0x0, + 0x2, 0xff, 0xf2, 0x2f, 0xff, 0x20, 0x4f, 0xff, + 0xa0, 0x0, 0x0, 0x2, 0xff, 0xf2, 0x2f, 0xff, + 0x20, 0x9, 0xff, 0xf4, 0x0, 0x0, 0x2, 0xff, + 0xf2, 0x2f, 0xff, 0x20, 0x0, 0xef, 0xfe, 0x10, + 0x0, 0x2, 0xff, 0xf2, 0x2f, 0xff, 0x20, 0x0, + 0x4f, 0xff, 0xa0, 0x0, 0x2, 0xff, 0xf2, 0x2f, + 0xff, 0x20, 0x0, 0x9, 0xff, 0xf4, 0x0, 0x2, + 0xff, 0xf2, 0x2f, 0xff, 0x20, 0x0, 0x1, 0xef, + 0xfe, 0x10, 0x2, 0xff, 0xf2, 0x2f, 0xff, 0x20, + 0x0, 0x0, 0x4f, 0xff, 0x90, 0x2, 0xff, 0xf2, + 0x2f, 0xff, 0x20, 0x0, 0x0, 0xa, 0xff, 0xf4, + 0x2, 0xff, 0xf2, 0x2f, 0xff, 0x20, 0x0, 0x0, + 0x1, 0xef, 0xfe, 0x2, 0xff, 0xf2, 0x2f, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x92, 0xff, + 0xf2, 0x2f, 0xff, 0x20, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf6, 0xff, 0xf2, 0x2f, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xf2, 0x2f, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xf2, 0x2f, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xf2, 0x2f, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xf2, + 0x2f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xf2, 0x2f, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf2, + + /* U+004F "O" */ + 0x0, 0x0, 0x0, 0x0, 0x38, 0xcd, 0xff, 0xdc, + 0x83, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xf9, 0x41, 0x0, 0x4, 0x9f, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfc, + 0x20, 0x0, 0x0, 0x0, 0x2, 0xcf, 0xff, 0x90, + 0x0, 0x0, 0x5f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf5, 0x0, 0x0, 0xdf, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xfd, 0x0, 0x5, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x50, + 0xa, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xa0, 0xe, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xe0, 0x1f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf1, 0x2f, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf3, 0x4f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf4, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf4, 0x4f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xf3, 0x1f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf2, + 0xe, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xe0, 0xa, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xa0, 0x5, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x50, 0x0, + 0xef, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xfd, 0x0, 0x0, 0x5f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf5, + 0x0, 0x0, 0xa, 0xff, 0xfc, 0x10, 0x0, 0x0, + 0x0, 0x1, 0xcf, 0xff, 0x90, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf9, 0x40, 0x0, 0x4, 0x9f, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4c, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x38, 0xce, 0xff, 0xec, 0x83, 0x0, 0x0, + 0x0, 0x0, + + /* U+0050 "P" */ + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xed, 0xb7, + 0x20, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x3, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x1, 0x38, 0xff, + 0xff, 0x50, 0x3f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xfd, 0x3, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf2, 0x3f, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x53, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xf6, 0x3f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x63, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xf4, 0x3f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0x3, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xa0, 0x3f, 0xff, + 0x30, 0x0, 0x0, 0x1, 0x25, 0xbf, 0xff, 0xf2, + 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe4, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0xc9, 0x50, 0x0, 0x0, + 0x3f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+0051 "Q" */ + 0x0, 0x0, 0x0, 0x0, 0x38, 0xcd, 0xff, 0xec, + 0x83, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xf9, 0x40, 0x0, 0x4, 0x9f, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfc, + 0x20, 0x0, 0x0, 0x0, 0x1, 0xcf, 0xff, 0xa0, + 0x0, 0x0, 0x5f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf5, 0x0, 0x0, 0xdf, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xfe, 0x0, 0x5, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x50, + 0xa, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xa0, 0xe, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xe0, 0x1f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf1, 0x3f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf3, 0x4f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf4, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf4, 0x3f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xf3, 0x1f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf1, + 0xe, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xe0, 0xa, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xa0, 0x4, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x1, 0x40, 0x0, 0x0, 0x5f, 0xff, 0x50, 0x0, + 0xcf, 0xfe, 0x10, 0x0, 0x0, 0x6, 0xfe, 0x70, + 0x0, 0xdf, 0xfd, 0x0, 0x0, 0x4f, 0xff, 0xb0, + 0x0, 0x0, 0xb, 0xff, 0xfe, 0x4b, 0xff, 0xf5, + 0x0, 0x0, 0x8, 0xff, 0xfc, 0x10, 0x0, 0x2, + 0x7e, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf9, 0x40, 0x0, 0x4, 0xef, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x4d, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc9, 0xff, 0xfd, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x38, 0xce, 0xff, 0xeb, 0x83, 0x0, 0x4e, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x60, + + /* U+0052 "R" */ + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xec, + 0x94, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xc1, 0x0, 0x0, + 0x1f, 0xff, 0xed, 0xdd, 0xdd, 0xdd, 0xde, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x1f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xef, 0xff, 0x80, 0x0, + 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xf0, 0x0, 0x1f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf4, 0x0, + 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf6, 0x0, 0x1f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf7, 0x0, + 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf6, 0x0, 0x1f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf2, 0x0, + 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xc0, 0x0, 0x1f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x2, 0x5a, 0xff, 0xff, 0x30, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0x30, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc6, + 0x20, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x40, 0x0, + 0x1, 0x4b, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xc1, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x90, 0x0, 0x0, 0x1f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xf4, 0x0, 0x0, + 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xfe, 0x0, 0x0, 0x1f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x90, 0x0, + 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xf4, 0x0, 0x1f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfe, 0x0, + 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0x90, 0x1f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xf4, + + /* U+0053 "S" */ + 0x0, 0x0, 0x0, 0x5a, 0xde, 0xff, 0xeb, 0x82, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5e, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb1, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x30, + 0x0, 0x0, 0x5f, 0xff, 0xe8, 0x31, 0x0, 0x15, + 0xbf, 0xff, 0xe1, 0x0, 0x0, 0xef, 0xfc, 0x10, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf9, 0x0, 0x3, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x0, 0x5, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x30, 0x5, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xa9, 0x20, + 0x2, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xa3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, + 0xff, 0xff, 0xe9, 0x51, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xdf, 0xff, 0xff, 0xff, 0xea, + 0x51, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xb3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0x8c, 0xff, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0x7c, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x17, 0xef, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2e, 0xff, 0xc0, 0x39, 0xbb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf0, 0x4f, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf1, 0x1f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf0, 0xc, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xc0, 0x4, + 0xff, 0xfe, 0x50, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0x60, 0x0, 0x9f, 0xff, 0xfd, 0x73, 0x10, + 0x13, 0x7d, 0xff, 0xfc, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0x5d, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x48, 0xbe, + 0xff, 0xfd, 0xa7, 0x10, 0x0, 0x0, + + /* U+0054 "T" */ + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf3, 0x3f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + + /* U+0055 "U" */ + 0x2f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xf2, 0x2f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf2, 0x2f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xf2, 0x2f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf2, 0x2f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf2, 0x2f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf2, 0x2f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xf2, 0x2f, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf2, + 0x2f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xf2, 0x2f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf2, 0x2f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xf2, 0x2f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf2, 0x2f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf2, 0x2f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf2, 0x2f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xf2, 0x1f, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf1, + 0xf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf1, 0xf, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf0, 0xd, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xd0, 0x9, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xa0, 0x5, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x60, 0x0, + 0xef, 0xff, 0x50, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xfe, 0x0, 0x0, 0x5f, 0xff, 0xfb, 0x63, 0x11, + 0x26, 0xbf, 0xff, 0xf5, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x6e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x59, 0xde, + 0xff, 0xec, 0x94, 0x0, 0x0, 0x0, + + /* U+0056 "V" */ + 0xaf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xf8, 0x4f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf2, + 0xd, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xc0, 0x7, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x60, + 0x1, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0x0, 0x0, 0xbf, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf9, 0x0, + 0x0, 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf3, 0x0, 0x0, 0xe, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xd0, 0x0, + 0x0, 0x9, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x70, 0x0, 0x0, 0x2, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x10, 0x0, + 0x0, 0x0, 0xcf, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x40, 0x0, 0x0, 0x5, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xa0, 0x0, 0x0, 0xb, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xf0, 0x0, 0x0, 0x1f, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xf5, 0x0, 0x0, 0x7f, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xfb, 0x0, 0x0, 0xdf, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x10, 0x2, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0x60, 0x8, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xc0, 0xe, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xf1, 0x3f, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf6, 0x8f, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfb, 0xdf, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0057 "W" */ + 0x7f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf5, 0x3f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf1, 0xf, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xd0, 0xb, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xdf, 0xff, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0x80, 0x7, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0x9b, 0xff, 0x50, 0x0, + 0x0, 0x0, 0xf, 0xff, 0x40, 0x2, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x9, 0xff, 0x57, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x0, 0x0, 0xef, + 0xf5, 0x0, 0x0, 0x0, 0xe, 0xff, 0x13, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x8f, 0xfb, 0x0, 0x0, + 0xaf, 0xf9, 0x0, 0x0, 0x0, 0x2f, 0xfc, 0x0, + 0xef, 0xf2, 0x0, 0x0, 0x0, 0xbf, 0xf7, 0x0, + 0x0, 0x6f, 0xfd, 0x0, 0x0, 0x0, 0x7f, 0xf8, + 0x0, 0xaf, 0xf7, 0x0, 0x0, 0x0, 0xff, 0xf3, + 0x0, 0x0, 0x2f, 0xff, 0x0, 0x0, 0x0, 0xbf, + 0xf3, 0x0, 0x6f, 0xfb, 0x0, 0x0, 0x3, 0xff, + 0xe0, 0x0, 0x0, 0xd, 0xff, 0x40, 0x0, 0x0, + 0xff, 0xf0, 0x0, 0x1f, 0xff, 0x0, 0x0, 0x7, + 0xff, 0xa0, 0x0, 0x0, 0x9, 0xff, 0x80, 0x0, + 0x4, 0xff, 0xb0, 0x0, 0xd, 0xff, 0x40, 0x0, + 0xb, 0xff, 0x60, 0x0, 0x0, 0x5, 0xff, 0xb0, + 0x0, 0x8, 0xff, 0x60, 0x0, 0x8, 0xff, 0x90, + 0x0, 0xf, 0xff, 0x10, 0x0, 0x0, 0x1, 0xff, + 0xf0, 0x0, 0xd, 0xff, 0x20, 0x0, 0x4, 0xff, + 0xd0, 0x0, 0x3f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xf3, 0x0, 0x1f, 0xfd, 0x0, 0x0, 0x0, + 0xff, 0xf1, 0x0, 0x7f, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xf6, 0x0, 0x6f, 0xf9, 0x0, 0x0, + 0x0, 0xbf, 0xf5, 0x0, 0xaf, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xfa, 0x0, 0xaf, 0xf4, 0x0, + 0x0, 0x0, 0x7f, 0xf9, 0x0, 0xef, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xfe, 0x0, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x2f, 0xfd, 0x2, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x13, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0xe, 0xff, 0x6, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x57, + 0xff, 0x70, 0x0, 0x0, 0x0, 0xa, 0xff, 0x3a, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0x8a, 0xff, 0x30, 0x0, 0x0, 0x0, 0x5, 0xff, + 0x6d, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xbe, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xaf, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x90, 0x0, + 0x0, 0x0, + + /* U+0058 "X" */ + 0x4, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xb0, 0x0, 0x9f, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfe, 0x10, + 0x0, 0xd, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xf3, 0x0, 0x0, 0x3, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x80, 0x0, 0x0, 0x1, + 0xef, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf4, 0x0, 0x0, 0xc, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xfe, 0x10, 0x0, 0x8f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xa0, 0x4, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf5, 0x1e, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xfe, 0xaf, 0xfe, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xfa, 0xbf, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xe1, 0x1f, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x50, 0x6, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xf9, 0x0, 0x0, 0xbf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, + 0xd0, 0x0, 0x0, 0x1e, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x30, 0x0, 0x0, 0x4, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x90, 0x0, + 0x0, 0x4f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xf4, 0x0, 0x1, 0xef, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfe, 0x10, + 0xb, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xb0, 0x7f, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf6, + + /* U+0059 "Y" */ + 0x9f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf6, 0xd, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xb0, + 0x3, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xfe, 0x10, 0x0, 0x9f, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf5, 0x0, + 0x0, 0xd, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xa0, 0x0, 0x0, 0x4, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x70, 0x0, 0x0, 0x7, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xf2, 0x0, 0x0, 0x2f, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xfb, 0x0, 0x0, 0xcf, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x50, 0x6, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xe0, 0x1e, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf8, 0x9f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+005A "Z" */ + 0x0, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x90, 0x0, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xdf, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2e, 0xff, 0xe2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf0, 0x5f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, + + /* U+005B "[" */ + 0x9f, 0xff, 0xff, 0xf6, 0x9f, 0xff, 0xff, 0xf6, + 0x9f, 0xfd, 0x99, 0x93, 0x9f, 0xf9, 0x0, 0x0, + 0x9f, 0xf9, 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x0, + 0x9f, 0xf9, 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x0, + 0x9f, 0xf9, 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x0, + 0x9f, 0xf9, 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x0, + 0x9f, 0xf9, 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x0, + 0x9f, 0xf9, 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x0, + 0x9f, 0xf9, 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x0, + 0x9f, 0xf9, 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x0, + 0x9f, 0xf9, 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x0, + 0x9f, 0xf9, 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x0, + 0x9f, 0xf9, 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x0, + 0x9f, 0xf9, 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x0, + 0x9f, 0xf9, 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x0, + 0x9f, 0xfd, 0x99, 0x93, 0x9f, 0xff, 0xff, 0xf6, + 0x9f, 0xff, 0xff, 0xf6, + + /* U+005C "\\" */ + 0xdf, 0xb0, 0x0, 0x0, 0x0, 0x9f, 0xf0, 0x0, + 0x0, 0x0, 0x4f, 0xf4, 0x0, 0x0, 0x0, 0xf, + 0xf8, 0x0, 0x0, 0x0, 0xb, 0xfd, 0x0, 0x0, + 0x0, 0x6, 0xff, 0x10, 0x0, 0x0, 0x2, 0xff, + 0x60, 0x0, 0x0, 0x0, 0xdf, 0xb0, 0x0, 0x0, + 0x0, 0x8f, 0xf0, 0x0, 0x0, 0x0, 0x4f, 0xf4, + 0x0, 0x0, 0x0, 0xf, 0xf8, 0x0, 0x0, 0x0, + 0xb, 0xfd, 0x0, 0x0, 0x0, 0x6, 0xff, 0x20, + 0x0, 0x0, 0x1, 0xff, 0x60, 0x0, 0x0, 0x0, + 0xdf, 0xb0, 0x0, 0x0, 0x0, 0x8f, 0xf0, 0x0, + 0x0, 0x0, 0x4f, 0xf4, 0x0, 0x0, 0x0, 0xf, + 0xf8, 0x0, 0x0, 0x0, 0xb, 0xfd, 0x0, 0x0, + 0x0, 0x6, 0xff, 0x20, 0x0, 0x0, 0x1, 0xff, + 0x60, 0x0, 0x0, 0x0, 0xdf, 0xb0, 0x0, 0x0, + 0x0, 0x8f, 0xf0, 0x0, 0x0, 0x0, 0x4f, 0xf4, + 0x0, 0x0, 0x0, 0xf, 0xf9, 0x0, 0x0, 0x0, + 0xa, 0xfd, + + /* U+005D "]" */ + 0x5f, 0xff, 0xff, 0xf9, 0x5f, 0xff, 0xff, 0xf9, + 0x39, 0x99, 0xdf, 0xf9, 0x0, 0x0, 0x8f, 0xf9, + 0x0, 0x0, 0x8f, 0xf9, 0x0, 0x0, 0x8f, 0xf9, + 0x0, 0x0, 0x8f, 0xf9, 0x0, 0x0, 0x8f, 0xf9, + 0x0, 0x0, 0x8f, 0xf9, 0x0, 0x0, 0x8f, 0xf9, + 0x0, 0x0, 0x8f, 0xf9, 0x0, 0x0, 0x8f, 0xf9, + 0x0, 0x0, 0x8f, 0xf9, 0x0, 0x0, 0x8f, 0xf9, + 0x0, 0x0, 0x8f, 0xf9, 0x0, 0x0, 0x8f, 0xf9, + 0x0, 0x0, 0x8f, 0xf9, 0x0, 0x0, 0x8f, 0xf9, + 0x0, 0x0, 0x8f, 0xf9, 0x0, 0x0, 0x8f, 0xf9, + 0x0, 0x0, 0x8f, 0xf9, 0x0, 0x0, 0x8f, 0xf9, + 0x0, 0x0, 0x8f, 0xf9, 0x0, 0x0, 0x8f, 0xf9, + 0x0, 0x0, 0x8f, 0xf9, 0x0, 0x0, 0x8f, 0xf9, + 0x0, 0x0, 0x8f, 0xf9, 0x0, 0x0, 0x8f, 0xf9, + 0x0, 0x0, 0x8f, 0xf9, 0x0, 0x0, 0x8f, 0xf9, + 0x39, 0x99, 0xdf, 0xf9, 0x5f, 0xff, 0xff, 0xf9, + 0x5f, 0xff, 0xff, 0xf9, + + /* U+005E "^" */ + 0x0, 0x0, 0x0, 0x1f, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xef, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0x4f, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xfa, 0xc, 0xff, 0x20, 0x0, + 0x0, 0x0, 0xbf, 0xf3, 0x5, 0xff, 0x90, 0x0, + 0x0, 0x2, 0xff, 0xd0, 0x0, 0xef, 0xf1, 0x0, + 0x0, 0x9, 0xff, 0x60, 0x0, 0x8f, 0xf7, 0x0, + 0x0, 0x1f, 0xff, 0x0, 0x0, 0x1f, 0xfe, 0x0, + 0x0, 0x7f, 0xf9, 0x0, 0x0, 0xb, 0xff, 0x60, + 0x0, 0xef, 0xf3, 0x0, 0x0, 0x4, 0xff, 0xd0, + 0x6, 0xff, 0xc0, 0x0, 0x0, 0x0, 0xdf, 0xf4, + 0xd, 0xff, 0x60, 0x0, 0x0, 0x0, 0x7f, 0xfb, + + /* U+005F "_" */ + 0x4, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, + 0x44, 0x44, 0x41, 0x3f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf3, + + /* U+0060 "`" */ + 0x1d, 0xee, 0xd0, 0x0, 0x4, 0xff, 0xf7, 0x0, + 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x9, 0xff, 0x70, + 0x0, 0x0, 0xcf, 0xe0, + + /* U+0061 "a" */ + 0x0, 0x0, 0x27, 0xbe, 0xff, 0xfd, 0xa4, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xc1, 0x0, 0x0, 0xaf, 0xff, 0xeb, 0xaa, 0xcf, + 0xff, 0xfc, 0x0, 0x5, 0xff, 0xf7, 0x0, 0x0, + 0x1, 0xbf, 0xff, 0x30, 0xc, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x60, 0xb, 0xdf, 0x20, + 0x0, 0x0, 0x0, 0xc, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x47, 0xaf, 0xff, 0x80, + 0x0, 0x0, 0x27, 0xad, 0xff, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x4c, 0xff, 0xff, 0xff, 0xff, 0xcd, + 0xff, 0x90, 0x6, 0xff, 0xff, 0xfb, 0x96, 0x30, + 0xa, 0xff, 0x90, 0x1f, 0xff, 0xd4, 0x0, 0x0, + 0x0, 0xb, 0xff, 0x90, 0x7f, 0xff, 0x10, 0x0, + 0x0, 0x0, 0xd, 0xff, 0x90, 0x9f, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x90, 0x8f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x90, 0x5f, + 0xff, 0x80, 0x0, 0x0, 0x2c, 0xff, 0xff, 0xa0, + 0xd, 0xff, 0xfd, 0x97, 0x9c, 0xff, 0xfe, 0xff, + 0xb0, 0x1, 0xdf, 0xff, 0xff, 0xff, 0xff, 0x73, + 0xff, 0xe0, 0x0, 0x6, 0xbe, 0xff, 0xeb, 0x71, + 0x0, 0xef, 0xf5, + + /* U+0062 "b" */ + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0x90, 0x29, 0xdf, + 0xec, 0x71, 0x0, 0x0, 0x9f, 0xf9, 0x6f, 0xff, + 0xff, 0xff, 0xe5, 0x0, 0x9, 0xff, 0xef, 0xff, + 0xb9, 0xbf, 0xff, 0xf5, 0x0, 0x9f, 0xff, 0xfa, + 0x10, 0x0, 0x1b, 0xff, 0xf2, 0x9, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xa0, 0x9f, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x19, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf4, 0x9f, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x79, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf8, + 0x9f, 0xf5, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0x99, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xf8, 0x9f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0x69, 0xff, 0x90, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xf3, 0x9f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfe, 0x9, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0x80, 0x9f, 0xff, 0xf9, 0x0, 0x0, + 0x2d, 0xff, 0xd0, 0x9, 0xff, 0xcf, 0xfe, 0xba, + 0xcf, 0xff, 0xe3, 0x0, 0x9f, 0xf5, 0x7f, 0xff, + 0xff, 0xff, 0xd2, 0x0, 0x9, 0xff, 0x50, 0x3a, + 0xef, 0xeb, 0x60, 0x0, 0x0, + + /* U+0063 "c" */ + 0x0, 0x0, 0x6, 0xae, 0xff, 0xd9, 0x40, 0x0, + 0x0, 0x0, 0x3d, 0xff, 0xff, 0xff, 0xff, 0xb1, + 0x0, 0x0, 0x4f, 0xff, 0xfd, 0xaa, 0xdf, 0xff, + 0xd0, 0x0, 0x1e, 0xff, 0xd3, 0x0, 0x0, 0x5f, + 0xff, 0x90, 0x9, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x0, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xe3, 0x4f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x2, 0x0, 0x7, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xfd, 0x70, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf6, 0x9, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x10, + 0x1e, 0xff, 0xc1, 0x0, 0x0, 0x5f, 0xff, 0x80, + 0x0, 0x4f, 0xff, 0xfc, 0xaa, 0xdf, 0xff, 0xb0, + 0x0, 0x0, 0x4e, 0xff, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x6, 0xbe, 0xff, 0xd9, 0x20, + 0x0, 0x0, + + /* U+0064 "d" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0x70, 0x0, 0x1, 0x8c, 0xef, + 0xd9, 0x20, 0xaf, 0xf7, 0x0, 0x6, 0xff, 0xff, + 0xff, 0xff, 0x5a, 0xff, 0x70, 0x6, 0xff, 0xff, + 0xba, 0xbf, 0xff, 0xdf, 0xf7, 0x3, 0xff, 0xfb, + 0x10, 0x0, 0x1b, 0xff, 0xff, 0x70, 0xbf, 0xfd, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf7, 0x1f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x75, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf7, 0x8f, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0x7a, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf7, + 0xbf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0x7a, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xf7, 0x8f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0x75, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf7, 0x1f, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x70, 0xaf, 0xfd, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf7, 0x1, 0xff, 0xfc, 0x20, 0x0, + 0x1a, 0xff, 0xff, 0x70, 0x4, 0xff, 0xff, 0xb9, + 0xbf, 0xff, 0xcf, 0xf7, 0x0, 0x4, 0xef, 0xff, + 0xff, 0xff, 0x77, 0xff, 0x70, 0x0, 0x0, 0x7c, + 0xef, 0xea, 0x30, 0x7f, 0xf7, + + /* U+0065 "e" */ + 0x0, 0x0, 0x4, 0xad, 0xff, 0xea, 0x50, 0x0, + 0x0, 0x0, 0x2, 0xcf, 0xff, 0xff, 0xff, 0xfd, + 0x30, 0x0, 0x0, 0x2e, 0xff, 0xfd, 0xa9, 0xcf, + 0xff, 0xf4, 0x0, 0x0, 0xdf, 0xfd, 0x30, 0x0, + 0x2, 0xbf, 0xfe, 0x10, 0x7, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0xb, 0xff, 0x90, 0xe, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf0, 0x3f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf4, 0x6f, + 0xff, 0x99, 0x99, 0x99, 0x99, 0x99, 0xef, 0xf7, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf9, 0x8f, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x54, 0x20, 0xf, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf4, 0x9, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0xc, 0xff, 0xe0, 0x1, + 0xef, 0xff, 0x50, 0x0, 0x2, 0xbf, 0xff, 0x50, + 0x0, 0x4f, 0xff, 0xfe, 0xaa, 0xcf, 0xff, 0xf9, + 0x0, 0x0, 0x3, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x5, 0xad, 0xff, 0xec, + 0x71, 0x0, 0x0, + + /* U+0066 "f" */ + 0x0, 0x0, 0x7, 0xce, 0xfe, 0xc1, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xf0, 0x0, 0x8, 0xff, 0xff, + 0xef, 0xd0, 0x0, 0xc, 0xff, 0xc1, 0x0, 0x0, + 0x0, 0xe, 0xff, 0x50, 0x0, 0x0, 0x0, 0xe, + 0xff, 0x30, 0x0, 0x0, 0x0, 0xe, 0xff, 0x30, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xfd, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xfd, 0x0, 0x57, 0x7f, + 0xff, 0x97, 0x76, 0x0, 0x0, 0xe, 0xff, 0x30, + 0x0, 0x0, 0x0, 0xe, 0xff, 0x30, 0x0, 0x0, + 0x0, 0xe, 0xff, 0x30, 0x0, 0x0, 0x0, 0xe, + 0xff, 0x30, 0x0, 0x0, 0x0, 0xe, 0xff, 0x30, + 0x0, 0x0, 0x0, 0xe, 0xff, 0x30, 0x0, 0x0, + 0x0, 0xe, 0xff, 0x30, 0x0, 0x0, 0x0, 0xe, + 0xff, 0x30, 0x0, 0x0, 0x0, 0xe, 0xff, 0x30, + 0x0, 0x0, 0x0, 0xe, 0xff, 0x30, 0x0, 0x0, + 0x0, 0xe, 0xff, 0x30, 0x0, 0x0, 0x0, 0xe, + 0xff, 0x30, 0x0, 0x0, 0x0, 0xe, 0xff, 0x30, + 0x0, 0x0, 0x0, 0xe, 0xff, 0x30, 0x0, 0x0, + 0x0, 0xe, 0xff, 0x30, 0x0, 0x0, 0x0, 0xe, + 0xff, 0x30, 0x0, 0x0, + + /* U+0067 "g" */ + 0x0, 0x0, 0x18, 0xce, 0xfe, 0x93, 0x3, 0xff, + 0xb0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xf8, 0x3f, + 0xfb, 0x0, 0x6f, 0xff, 0xfb, 0xab, 0xff, 0xfc, + 0xff, 0xb0, 0x2f, 0xff, 0xc1, 0x0, 0x0, 0xaf, + 0xff, 0xfb, 0xb, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xb1, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xfb, 0x6f, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xb9, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xfb, 0xbf, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xbb, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xfb, 0xbf, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xb9, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfb, 0x6f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xb1, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfb, 0xb, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xb0, + 0x2f, 0xff, 0xb2, 0x0, 0x0, 0x9f, 0xff, 0xfb, + 0x0, 0x6f, 0xff, 0xfc, 0xab, 0xff, 0xfe, 0xff, + 0xa0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xf7, 0x8f, + 0xfa, 0x0, 0x0, 0x18, 0xce, 0xfe, 0x93, 0x9, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xf7, 0x18, 0x64, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x40, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf0, 0xc, 0xff, 0xd2, 0x0, 0x0, + 0x6, 0xff, 0xf8, 0x0, 0x3f, 0xff, 0xfc, 0xaa, + 0xbe, 0xff, 0xfc, 0x0, 0x0, 0x4e, 0xff, 0xff, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x16, 0xbe, + 0xff, 0xec, 0x82, 0x0, 0x0, + + /* U+0068 "h" */ + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf9, 0x1, 0x7c, 0xef, 0xeb, 0x50, 0x0, + 0x9f, 0xf9, 0x5e, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0x9f, 0xfd, 0xff, 0xfd, 0xbd, 0xff, 0xff, 0x90, + 0x9f, 0xff, 0xfb, 0x20, 0x0, 0x2c, 0xff, 0xf1, + 0x9f, 0xff, 0xa0, 0x0, 0x0, 0x2, 0xff, 0xf5, + 0x9f, 0xff, 0x20, 0x0, 0x0, 0x0, 0xbf, 0xf8, + 0x9f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf9, + 0x9f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfa, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfa, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfa, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfa, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfa, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfa, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfa, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfa, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfa, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfa, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfa, + + /* U+0069 "i" */ + 0x9f, 0xf9, 0x9f, 0xf9, 0x9f, 0xf9, 0x5a, 0xa5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf9, + 0x9f, 0xf9, 0x9f, 0xf9, 0x9f, 0xf9, 0x9f, 0xf9, + 0x9f, 0xf9, 0x9f, 0xf9, 0x9f, 0xf9, 0x9f, 0xf9, + 0x9f, 0xf9, 0x9f, 0xf9, 0x9f, 0xf9, 0x9f, 0xf9, + 0x9f, 0xf9, 0x9f, 0xf9, 0x9f, 0xf9, 0x9f, 0xf9, + 0x9f, 0xf9, 0x9f, 0xf9, + + /* U+006A "j" */ + 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x0, 0x9f, 0xf9, + 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x0, 0x6a, 0xa6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf9, + 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x0, 0x9f, 0xf9, + 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x0, 0x9f, 0xf9, + 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x0, 0x9f, 0xf9, + 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x0, 0x9f, 0xf9, + 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x0, 0x9f, 0xf9, + 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x0, 0x9f, 0xf9, + 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x0, 0x9f, 0xf9, + 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x0, 0x9f, 0xf9, + 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x0, 0x9f, 0xf9, + 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x0, 0x9f, 0xf8, + 0x0, 0x0, 0xbf, 0xf7, 0x0, 0x1, 0xff, 0xf4, + 0x1e, 0xcf, 0xff, 0xf0, 0x5f, 0xff, 0xff, 0x70, + 0x5e, 0xff, 0xc6, 0x0, + + /* U+006B "k" */ + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x90, + 0x9f, 0xf9, 0x0, 0x0, 0x6, 0xff, 0xf9, 0x0, + 0x9f, 0xf9, 0x0, 0x0, 0x6f, 0xff, 0x90, 0x0, + 0x9f, 0xf9, 0x0, 0x5, 0xff, 0xf9, 0x0, 0x0, + 0x9f, 0xf9, 0x0, 0x5f, 0xff, 0x90, 0x0, 0x0, + 0x9f, 0xf9, 0x4, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x9f, 0xf9, 0x4f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x9f, 0xfc, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xf9, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0x80, 0x7f, 0xff, 0x40, 0x0, 0x0, + 0x9f, 0xfa, 0x0, 0xc, 0xff, 0xe0, 0x0, 0x0, + 0x9f, 0xf9, 0x0, 0x3, 0xff, 0xf9, 0x0, 0x0, + 0x9f, 0xf9, 0x0, 0x0, 0x8f, 0xff, 0x30, 0x0, + 0x9f, 0xf9, 0x0, 0x0, 0xd, 0xff, 0xd0, 0x0, + 0x9f, 0xf9, 0x0, 0x0, 0x4, 0xff, 0xf8, 0x0, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x30, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xd0, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, + + /* U+006C "l" */ + 0xaf, 0xf8, 0xaf, 0xf8, 0xaf, 0xf8, 0xaf, 0xf8, + 0xaf, 0xf8, 0xaf, 0xf8, 0xaf, 0xf8, 0xaf, 0xf8, + 0xaf, 0xf8, 0xaf, 0xf8, 0xaf, 0xf8, 0xaf, 0xf8, + 0xaf, 0xf8, 0xaf, 0xf8, 0xaf, 0xf8, 0xaf, 0xf8, + 0xaf, 0xf8, 0xaf, 0xf8, 0xaf, 0xf8, 0xaf, 0xf8, + 0xaf, 0xf8, 0xaf, 0xf8, 0xaf, 0xf8, 0xaf, 0xf8, + 0xaf, 0xf8, 0xaf, 0xf8, + + /* U+006D "m" */ + 0xaf, 0xf3, 0x2, 0x9d, 0xfe, 0xc7, 0x10, 0x0, + 0x18, 0xdf, 0xfd, 0x81, 0x0, 0xaf, 0xf3, 0x6f, + 0xff, 0xff, 0xff, 0xd1, 0x5, 0xff, 0xff, 0xff, + 0xfe, 0x20, 0xaf, 0xf8, 0xff, 0xfc, 0xcf, 0xff, + 0xfb, 0x4f, 0xff, 0xcc, 0xef, 0xff, 0xd0, 0xaf, + 0xff, 0xf9, 0x10, 0x0, 0xaf, 0xff, 0xff, 0x91, + 0x0, 0x9, 0xff, 0xf4, 0xaf, 0xff, 0x80, 0x0, + 0x0, 0xf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0xef, + 0xf7, 0xaf, 0xff, 0x10, 0x0, 0x0, 0xa, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0xaf, 0xf9, 0xaf, 0xfc, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x8f, 0xfa, 0xaf, 0xf9, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x8f, 0xfa, + 0xaf, 0xf8, 0x0, 0x0, 0x0, 0x8, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x8f, 0xfa, 0xaf, 0xf8, 0x0, + 0x0, 0x0, 0x8, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x8f, 0xfa, 0xaf, 0xf8, 0x0, 0x0, 0x0, 0x8, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x8f, 0xfa, 0xaf, + 0xf8, 0x0, 0x0, 0x0, 0x8, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x8f, 0xfa, 0xaf, 0xf8, 0x0, 0x0, + 0x0, 0x8, 0xff, 0x90, 0x0, 0x0, 0x0, 0x8f, + 0xfa, 0xaf, 0xf8, 0x0, 0x0, 0x0, 0x8, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x8f, 0xfa, 0xaf, 0xf8, + 0x0, 0x0, 0x0, 0x8, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x8f, 0xfa, 0xaf, 0xf8, 0x0, 0x0, 0x0, + 0x8, 0xff, 0x90, 0x0, 0x0, 0x0, 0x8f, 0xfa, + 0xaf, 0xf8, 0x0, 0x0, 0x0, 0x8, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x8f, 0xfa, 0xaf, 0xf8, 0x0, + 0x0, 0x0, 0x8, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x8f, 0xfa, 0xaf, 0xf8, 0x0, 0x0, 0x0, 0x8, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x8f, 0xfa, + + /* U+006E "n" */ + 0x9f, 0xf4, 0x1, 0x7c, 0xef, 0xda, 0x40, 0x0, + 0x9f, 0xf4, 0x4e, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x9f, 0xf8, 0xff, 0xfd, 0xcd, 0xff, 0xff, 0xa0, + 0x9f, 0xff, 0xfb, 0x20, 0x0, 0x2d, 0xff, 0xf2, + 0x9f, 0xff, 0xa0, 0x0, 0x0, 0x2, 0xff, 0xf5, + 0x9f, 0xff, 0x20, 0x0, 0x0, 0x0, 0xcf, 0xf8, + 0x9f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf9, + 0x9f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x9f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + + /* U+006F "o" */ + 0x0, 0x0, 0x5, 0xad, 0xff, 0xda, 0x60, 0x0, + 0x0, 0x0, 0x3, 0xdf, 0xff, 0xff, 0xff, 0xfd, + 0x30, 0x0, 0x0, 0x5f, 0xff, 0xfd, 0xaa, 0xdf, + 0xff, 0xf5, 0x0, 0x3, 0xff, 0xfd, 0x30, 0x0, + 0x3, 0xdf, 0xff, 0x20, 0xb, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xb0, 0x2f, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf2, 0x6f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf6, 0x9f, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf9, + 0xaf, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xfb, 0xbf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xfb, 0xaf, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xfa, 0x9f, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xf9, 0x6f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xf6, 0x2f, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf2, 0xb, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xb0, 0x3, + 0xff, 0xfd, 0x30, 0x0, 0x3, 0xdf, 0xff, 0x20, + 0x0, 0x5f, 0xff, 0xfd, 0xaa, 0xcf, 0xff, 0xf5, + 0x0, 0x0, 0x3, 0xdf, 0xff, 0xff, 0xff, 0xfe, + 0x40, 0x0, 0x0, 0x0, 0x5, 0xad, 0xff, 0xea, + 0x60, 0x0, 0x0, + + /* U+0070 "p" */ + 0x9f, 0xf5, 0x3, 0x9d, 0xfe, 0xc8, 0x10, 0x0, + 0x9, 0xff, 0x57, 0xff, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x9f, 0xfb, 0xff, 0xe9, 0x79, 0xef, 0xff, + 0x60, 0x9, 0xff, 0xff, 0xa0, 0x0, 0x1, 0xbf, + 0xff, 0x20, 0x9f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0xdf, 0xfa, 0x9, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xf1, 0x9f, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0x59, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xf8, 0x9f, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0x99, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xfa, 0x9f, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0x99, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf7, 0x9f, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x39, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x5, 0xff, 0xe0, 0x9f, + 0xff, 0x90, 0x0, 0x0, 0x1, 0xef, 0xf8, 0x9, + 0xff, 0xff, 0x80, 0x0, 0x3, 0xdf, 0xfe, 0x10, + 0x9f, 0xff, 0xff, 0xea, 0x9c, 0xff, 0xff, 0x30, + 0x9, 0xff, 0x98, 0xff, 0xff, 0xff, 0xfd, 0x30, + 0x0, 0x9f, 0xf9, 0x3, 0xae, 0xfe, 0xb6, 0x0, + 0x0, 0x9, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0071 "q" */ + 0x0, 0x0, 0x18, 0xce, 0xfd, 0x92, 0x5, 0xff, + 0x80, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xf6, 0x5f, + 0xf8, 0x0, 0x6f, 0xff, 0xe9, 0x89, 0xef, 0xfa, + 0xff, 0x80, 0x2f, 0xff, 0xa0, 0x0, 0x0, 0xaf, + 0xff, 0xf8, 0xb, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x81, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf8, 0x5f, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0x88, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf8, 0x9f, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0x8a, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf8, 0x9f, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0x87, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf8, 0x3f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0x80, 0xef, + 0xf6, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf8, 0x8, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x80, + 0xd, 0xff, 0xd2, 0x0, 0x0, 0x9f, 0xff, 0xf8, + 0x0, 0x3f, 0xff, 0xfc, 0x9a, 0xff, 0xfe, 0xff, + 0x80, 0x0, 0x3d, 0xff, 0xff, 0xff, 0xf7, 0xaf, + 0xf8, 0x0, 0x0, 0x6, 0xbe, 0xfd, 0x92, 0xa, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xf8, + + /* U+0072 "r" */ + 0xaf, 0xf3, 0x7, 0xdf, 0xd9, 0x2a, 0xff, 0x39, + 0xff, 0xff, 0xf3, 0xaf, 0xf8, 0xff, 0xff, 0xfd, + 0xa, 0xff, 0xff, 0xa5, 0x58, 0x70, 0xaf, 0xff, + 0x90, 0x0, 0x0, 0xa, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0xa, 0xff, + 0x90, 0x0, 0x0, 0x0, 0xaf, 0xf8, 0x0, 0x0, + 0x0, 0xa, 0xff, 0x80, 0x0, 0x0, 0x0, 0xaf, + 0xf8, 0x0, 0x0, 0x0, 0xa, 0xff, 0x80, 0x0, + 0x0, 0x0, 0xaf, 0xf8, 0x0, 0x0, 0x0, 0xa, + 0xff, 0x80, 0x0, 0x0, 0x0, 0xaf, 0xf8, 0x0, + 0x0, 0x0, 0xa, 0xff, 0x80, 0x0, 0x0, 0x0, + 0xaf, 0xf8, 0x0, 0x0, 0x0, 0xa, 0xff, 0x80, + 0x0, 0x0, 0x0, 0xaf, 0xf8, 0x0, 0x0, 0x0, + 0x0, + + /* U+0073 "s" */ + 0x0, 0x2, 0x8c, 0xff, 0xfd, 0x94, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xc2, 0x0, + 0x7, 0xff, 0xfe, 0xb9, 0xad, 0xff, 0xfd, 0x0, + 0x1f, 0xff, 0x60, 0x0, 0x0, 0x5f, 0xff, 0x70, + 0x4f, 0xfc, 0x0, 0x0, 0x0, 0x8, 0xff, 0xc0, + 0x5f, 0xfd, 0x0, 0x0, 0x0, 0x2, 0x75, 0x20, + 0x2f, 0xff, 0xa2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xd8, 0x40, 0x0, 0x0, 0x0, + 0x1, 0xcf, 0xff, 0xff, 0xff, 0xb6, 0x10, 0x0, + 0x0, 0x6, 0xcf, 0xff, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x1, 0x6a, 0xef, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0x8e, 0xff, 0xf4, + 0x1, 0x31, 0x0, 0x0, 0x0, 0x1, 0xef, 0xf8, + 0xbf, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf9, + 0x8f, 0xfd, 0x10, 0x0, 0x0, 0x0, 0xdf, 0xf6, + 0x1f, 0xff, 0xc2, 0x0, 0x0, 0x1a, 0xff, 0xf1, + 0x6, 0xff, 0xff, 0xca, 0x9b, 0xff, 0xff, 0x60, + 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x1, 0x7b, 0xef, 0xfe, 0xb7, 0x10, 0x0, + + /* U+0074 "t" */ + 0x0, 0x0, 0x2, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0x0, 0x0, 0x0, 0xe, 0xff, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xf3, + 0x6f, 0xff, 0xff, 0xff, 0xf3, 0x37, 0x8f, 0xff, + 0x77, 0x71, 0x0, 0x1f, 0xff, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x10, 0x0, 0x0, 0xf, + 0xff, 0x70, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf5, + 0x0, 0x6, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x5c, + 0xef, 0xe7, + + /* U+0075 "u" */ + 0xaf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf8, + 0xaf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf8, + 0xaf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf8, + 0xaf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf8, + 0xaf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf8, + 0xaf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf8, + 0xaf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf8, + 0xaf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf8, + 0xaf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf8, + 0xaf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf8, + 0xaf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf8, + 0x9f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf8, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf8, + 0x8f, 0xfb, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf8, + 0x6f, 0xff, 0x10, 0x0, 0x0, 0xb, 0xff, 0xf8, + 0x2f, 0xff, 0xd2, 0x0, 0x2, 0xbf, 0xff, 0xf8, + 0x9, 0xff, 0xff, 0xdb, 0xdf, 0xff, 0x7f, 0xf8, + 0x0, 0xaf, 0xff, 0xff, 0xff, 0xe3, 0x5f, 0xf8, + 0x0, 0x4, 0xad, 0xfe, 0xc7, 0x0, 0x5f, 0xf8, + + /* U+0076 "v" */ + 0x5f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xf6, 0xf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf0, 0x9, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xa0, 0x3, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0x40, 0x0, 0xdf, 0xf6, 0x0, + 0x0, 0x0, 0x4f, 0xfe, 0x0, 0x0, 0x7f, 0xfb, + 0x0, 0x0, 0x0, 0xaf, 0xf8, 0x0, 0x0, 0x1f, + 0xff, 0x10, 0x0, 0x0, 0xff, 0xf2, 0x0, 0x0, + 0xb, 0xff, 0x70, 0x0, 0x5, 0xff, 0xc0, 0x0, + 0x0, 0x5, 0xff, 0xc0, 0x0, 0xb, 0xff, 0x60, + 0x0, 0x0, 0x0, 0xff, 0xf2, 0x0, 0x1f, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x9f, 0xf8, 0x0, 0x7f, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfd, 0x0, + 0xcf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0x22, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0x77, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xcc, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xb0, + 0x0, 0x0, 0x0, + + /* U+0077 "w" */ + 0xaf, 0xf9, 0x0, 0x0, 0x0, 0xa, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x6f, 0xfa, 0x6f, 0xfd, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0xbf, 0xf5, 0x1f, 0xff, 0x20, 0x0, 0x0, 0x3f, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0xff, 0xf0, 0xc, + 0xff, 0x60, 0x0, 0x0, 0x7f, 0xff, 0xf9, 0x0, + 0x0, 0x4, 0xff, 0xb0, 0x7, 0xff, 0xa0, 0x0, + 0x0, 0xbf, 0xef, 0xfd, 0x0, 0x0, 0x9, 0xff, + 0x60, 0x2, 0xff, 0xe0, 0x0, 0x0, 0xff, 0xac, + 0xff, 0x10, 0x0, 0xe, 0xff, 0x10, 0x0, 0xdf, + 0xf3, 0x0, 0x4, 0xff, 0x69, 0xff, 0x50, 0x0, + 0x2f, 0xfc, 0x0, 0x0, 0x9f, 0xf7, 0x0, 0x8, + 0xff, 0x25, 0xff, 0x90, 0x0, 0x7f, 0xf7, 0x0, + 0x0, 0x4f, 0xfc, 0x0, 0xd, 0xfe, 0x1, 0xff, + 0xd0, 0x0, 0xcf, 0xf2, 0x0, 0x0, 0xf, 0xff, + 0x0, 0x1f, 0xfa, 0x0, 0xdf, 0xf2, 0x1, 0xff, + 0xd0, 0x0, 0x0, 0xa, 0xff, 0x40, 0x5f, 0xf6, + 0x0, 0x8f, 0xf6, 0x5, 0xff, 0x80, 0x0, 0x0, + 0x5, 0xff, 0x90, 0x9f, 0xf2, 0x0, 0x4f, 0xfa, + 0xa, 0xff, 0x40, 0x0, 0x0, 0x1, 0xff, 0xd0, + 0xdf, 0xd0, 0x0, 0xf, 0xfe, 0xe, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xf3, 0xff, 0x90, 0x0, + 0xc, 0xff, 0x5f, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfb, 0xff, 0x50, 0x0, 0x8, 0xff, 0xef, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x10, 0x0, 0x3, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x10, 0x0, 0x0, + + /* U+0078 "x" */ + 0xd, 0xff, 0xf1, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xd0, 0x3, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x30, 0x0, 0x7f, 0xff, 0x50, 0x0, 0x4, + 0xff, 0xf7, 0x0, 0x0, 0xc, 0xff, 0xe1, 0x0, + 0x1e, 0xff, 0xb0, 0x0, 0x0, 0x2, 0xff, 0xf9, + 0x0, 0xbf, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x46, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xdf, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xee, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x55, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xfb, 0x0, 0xbf, 0xfe, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xe1, 0x0, 0x1f, 0xff, 0xa0, 0x0, 0x0, + 0x5f, 0xff, 0x60, 0x0, 0x6, 0xff, 0xf5, 0x0, + 0x1, 0xef, 0xfb, 0x0, 0x0, 0x0, 0xcf, 0xfe, + 0x10, 0xb, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xb0, 0x6f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xf6, + + /* U+0079 "y" */ + 0x3f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xf7, 0xd, 0xff, 0x80, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xf2, 0x7, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xb0, 0x1, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0xc, 0xff, 0x50, 0x0, 0xbf, 0xf9, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x0, 0x0, 0x5f, 0xff, + 0x0, 0x0, 0x0, 0x8f, 0xf9, 0x0, 0x0, 0xe, + 0xff, 0x50, 0x0, 0x0, 0xef, 0xf3, 0x0, 0x0, + 0x8, 0xff, 0xb0, 0x0, 0x4, 0xff, 0xd0, 0x0, + 0x0, 0x2, 0xff, 0xf1, 0x0, 0xa, 0xff, 0x70, + 0x0, 0x0, 0x0, 0xcf, 0xf6, 0x0, 0xf, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x6f, 0xfc, 0x0, 0x5f, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x10, + 0xbf, 0xf5, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0x71, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xc5, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xfb, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x31, + 0x28, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9e, 0xfd, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+007A "z" */ + 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xa0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xa0, 0x4, 0x88, 0x88, 0x88, 0x88, 0x88, + 0xcf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xe9, 0xab, 0xbb, 0xbb, 0xbb, 0xbb, + 0xb2, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf3, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf3, + + /* U+007B "{" */ + 0x0, 0x0, 0x2, 0x9d, 0xff, 0x30, 0x0, 0x2, + 0xef, 0xff, 0xf3, 0x0, 0x0, 0xbf, 0xff, 0xdc, + 0x20, 0x0, 0xf, 0xff, 0x30, 0x0, 0x0, 0x2, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x4f, 0xfa, 0x0, + 0x0, 0x0, 0x4, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x5f, 0xf9, 0x0, 0x0, 0x0, 0x5, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x6f, 0xf9, 0x0, 0x0, 0x0, + 0x6, 0xff, 0x80, 0x0, 0x0, 0x0, 0x8f, 0xf7, + 0x0, 0x0, 0x0, 0xb, 0xff, 0x40, 0x0, 0x0, + 0x1, 0xff, 0xf0, 0x0, 0x0, 0x4, 0xdf, 0xf6, + 0x0, 0x0, 0xf, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x2, 0xcf, 0xf7, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xf0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x8f, 0xf7, 0x0, + 0x0, 0x0, 0x6, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x6f, 0xf9, 0x0, 0x0, 0x0, 0x5, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x5f, 0xfa, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x4f, 0xfa, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0x30, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xdb, 0x20, 0x0, 0x1, 0xef, 0xff, 0xf3, + 0x0, 0x0, 0x2, 0xae, 0xff, 0x30, + + /* U+007C "|" */ + 0xbf, 0xf1, 0xbf, 0xf1, 0xbf, 0xf1, 0xbf, 0xf1, + 0xbf, 0xf1, 0xbf, 0xf1, 0xbf, 0xf1, 0xbf, 0xf1, + 0xbf, 0xf1, 0xbf, 0xf1, 0xbf, 0xf1, 0xbf, 0xf1, + 0xbf, 0xf1, 0xbf, 0xf1, 0xbf, 0xf1, 0xbf, 0xf1, + 0xbf, 0xf1, 0xbf, 0xf1, 0xbf, 0xf1, 0xbf, 0xf1, + 0xbf, 0xf1, 0xbf, 0xf1, 0xbf, 0xf1, 0xbf, 0xf1, + 0xbf, 0xf1, 0xbf, 0xf1, 0xbf, 0xf1, 0xbf, 0xf1, + 0xbf, 0xf1, 0xbf, 0xf1, 0xbf, 0xf1, 0xbf, 0xf1, + 0xbf, 0xf1, + + /* U+007D "}" */ + 0x2f, 0xfe, 0xa2, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xe2, 0x0, 0x0, 0x2c, 0xdf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xf3, 0x0, 0x0, 0x0, 0xa, 0xff, 0x40, + 0x0, 0x0, 0x0, 0xaf, 0xf5, 0x0, 0x0, 0x0, + 0x9, 0xff, 0x50, 0x0, 0x0, 0x0, 0x9f, 0xf5, + 0x0, 0x0, 0x0, 0x9, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x8f, 0xf7, 0x0, 0x0, 0x0, 0x7, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x4f, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xd4, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0x0, 0x0, 0x7, 0xff, 0xc2, + 0x0, 0x0, 0x0, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x4f, 0xfb, 0x0, 0x0, 0x0, 0x7, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x8f, 0xf6, 0x0, 0x0, 0x0, + 0x9, 0xff, 0x60, 0x0, 0x0, 0x0, 0x9f, 0xf5, + 0x0, 0x0, 0x0, 0x9, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x9f, 0xf5, 0x0, 0x0, 0x0, 0xa, 0xff, + 0x40, 0x0, 0x0, 0x0, 0xcf, 0xf2, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0x0, 0x0, 0x2b, 0xdf, 0xff, + 0xa0, 0x0, 0x2, 0xff, 0xff, 0xe2, 0x0, 0x0, + 0x2f, 0xfd, 0x92, 0x0, 0x0, 0x0, + + /* U+007E "~" */ + 0x0, 0x1, 0x34, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x10, 0x3b, 0xff, 0xff, 0xfc, 0x72, 0x0, + 0x0, 0x0, 0x98, 0x5f, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x85, 0x59, 0xef, 0x87, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x7f, 0xb4, + 0x10, 0x37, 0xcf, 0xff, 0xff, 0xff, 0xfe, 0x36, + 0x50, 0x0, 0x0, 0x0, 0x26, 0xbd, 0xfe, 0xc7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+00A0 " " */ + + /* U+00A3 "£" */ + 0x0, 0x0, 0x0, 0x17, 0xce, 0xff, 0xc8, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xfb, 0x9b, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x6, + 0xff, 0xfa, 0x10, 0x0, 0x9, 0xff, 0xf6, 0x0, + 0x0, 0xe, 0xff, 0xb0, 0x0, 0x0, 0x0, 0xaf, + 0xfe, 0x0, 0x0, 0x2f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x30, 0x0, 0x4f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xa8, 0x20, 0x0, 0x4f, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x19, 0x9c, + 0xff, 0xf9, 0x99, 0x99, 0x50, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1a, 0xff, 0xfc, 0xff, + 0xec, 0xa7, 0x41, 0x1, 0x5a, 0x30, 0x4f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, + 0xd, 0xff, 0xeb, 0x99, 0xbe, 0xff, 0xff, 0xff, + 0xff, 0xe0, 0x7, 0xa3, 0x0, 0x0, 0x0, 0x26, + 0xad, 0xfe, 0xc8, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00A4 "¤" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xc1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1c, 0x30, 0x2e, 0xfd, 0x10, 0x6b, 0xdd, 0xb6, + 0x11, 0xdf, 0xe3, 0x3f, 0xff, 0xde, 0xff, 0xff, + 0xff, 0xed, 0xff, 0xf3, 0x3, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x30, 0x0, 0x5f, 0xff, + 0xb4, 0x0, 0x4c, 0xff, 0xf6, 0x0, 0x0, 0xcf, + 0xfa, 0x0, 0x0, 0x0, 0xaf, 0xfc, 0x0, 0x2, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0xe, 0xff, 0x20, + 0x5, 0xff, 0x90, 0x0, 0x0, 0x0, 0x9, 0xff, + 0x50, 0x6, 0xff, 0x70, 0x0, 0x0, 0x0, 0x7, + 0xff, 0x60, 0x5, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x9, 0xff, 0x50, 0x2, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0x20, 0x0, 0xcf, 0xf8, 0x0, + 0x0, 0x0, 0x9f, 0xfd, 0x0, 0x0, 0x5f, 0xff, + 0xa2, 0x0, 0x2a, 0xff, 0xf6, 0x0, 0x2, 0xdf, + 0xff, 0xff, 0xee, 0xff, 0xff, 0xfe, 0x20, 0x2e, + 0xff, 0xef, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xe2, + 0x4f, 0xfe, 0x22, 0x8d, 0xff, 0xd8, 0x22, 0xef, + 0xf4, 0x4, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2e, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+00A5 "¥" */ + 0xbf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xfb, 0x2f, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xf2, 0x9, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x90, 0x1, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x10, + 0x0, 0x8f, 0xfe, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xf8, 0x0, 0x0, 0xe, 0xff, 0x80, 0x0, 0x0, + 0xa, 0xff, 0xe0, 0x0, 0x0, 0x6, 0xff, 0xf1, + 0x0, 0x0, 0x2f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0xdf, 0xf9, 0x0, 0x0, 0xaf, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x20, 0x3, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xa0, 0xb, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf2, 0x3f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xfa, 0xbf, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd0, 0xd, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x7, 0x99, + 0x99, 0x99, 0xcf, 0xfd, 0x99, 0x99, 0x99, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0xd, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, + 0x5, 0x66, 0x66, 0x66, 0xbf, 0xfc, 0x66, 0x66, + 0x66, 0x50, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfa, + 0x0, 0x0, 0x0, 0x0, + + /* U+00A6 "¦" */ + 0xbf, 0xf1, 0xbf, 0xf1, 0xbf, 0xf1, 0xbf, 0xf1, + 0xbf, 0xf1, 0xbf, 0xf1, 0xbf, 0xf1, 0xbf, 0xf1, + 0xbf, 0xf1, 0xbf, 0xf1, 0xbf, 0xf1, 0xbf, 0xf1, + 0xbf, 0xf1, 0x8d, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9d, 0xd0, + 0xbf, 0xf1, 0xbf, 0xf1, 0xbf, 0xf1, 0xbf, 0xf1, + 0xbf, 0xf1, 0xbf, 0xf1, 0xbf, 0xf1, 0xbf, 0xf1, + 0xbf, 0xf1, 0xbf, 0xf1, 0xbf, 0xf1, 0xbf, 0xf1, + 0xbf, 0xf1, + + /* U+00A7 "§" */ + 0x0, 0x0, 0x5, 0xbe, 0xff, 0xd9, 0x30, 0x0, + 0x0, 0x0, 0x1, 0xcf, 0xff, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xfd, 0xab, 0xef, + 0xff, 0xa0, 0x0, 0x0, 0x5f, 0xff, 0x50, 0x0, + 0xa, 0xff, 0xf3, 0x0, 0x0, 0xbf, 0xf7, 0x0, + 0x0, 0x0, 0xef, 0xf9, 0x0, 0x0, 0xcf, 0xf5, + 0x0, 0x0, 0x0, 0x8f, 0xfd, 0x0, 0x0, 0xaf, + 0xfa, 0x0, 0x0, 0x0, 0x13, 0x20, 0x0, 0x0, + 0x4f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfb, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xe5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4d, 0xff, 0xff, 0xff, 0xc2, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xe3, 0x4e, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x1f, 0xfe, 0x20, 0x1, + 0xaf, 0xff, 0xfd, 0x30, 0x0, 0x5f, 0xf8, 0x0, + 0x0, 0x4, 0xdf, 0xff, 0xf5, 0x0, 0x7f, 0xf6, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x50, 0x6f, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xe0, + 0x2f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xf4, 0x9, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf6, 0x0, 0xcf, 0xff, 0xb2, 0x0, 0x0, + 0x0, 0x9f, 0xf5, 0x0, 0x9, 0xff, 0xff, 0x80, + 0x0, 0x0, 0xdf, 0xf1, 0x0, 0x0, 0x5e, 0xff, + 0xfd, 0x40, 0x8, 0xff, 0x70, 0x0, 0x0, 0x1, + 0x9f, 0xff, 0xf9, 0xbf, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xdf, 0xff, 0xfc, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2d, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xfd, 0x0, 0x1, 0x57, 0x80, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x20, 0x4, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0xf, 0xff, 0x30, 0x0, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0x10, 0x0, 0x9f, 0xff, + 0x80, 0x0, 0x3, 0xef, 0xfc, 0x0, 0x0, 0xd, + 0xff, 0xfe, 0xcb, 0xdf, 0xff, 0xf2, 0x0, 0x0, + 0x1, 0xbf, 0xff, 0xff, 0xff, 0xfe, 0x30, 0x0, + 0x0, 0x0, 0x4, 0xad, 0xff, 0xeb, 0x60, 0x0, + 0x0, + + /* U+00A8 "¨" */ + 0x89, 0x93, 0x0, 0x39, 0x98, 0xef, 0xf6, 0x0, + 0x6f, 0xff, 0xef, 0xf6, 0x0, 0x6f, 0xff, 0xef, + 0xf6, 0x0, 0x6f, 0xff, + + /* U+00A9 "©" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x22, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0x9d, 0xff, 0xff, 0xfc, 0x72, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5d, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xbf, 0xff, 0xa5, 0x21, 0x1, + 0x48, 0xdf, 0xfe, 0x40, 0x0, 0x0, 0x0, 0x1, + 0xdf, 0xfa, 0x10, 0x0, 0x0, 0x0, 0x0, 0x5d, + 0xff, 0x60, 0x0, 0x0, 0x0, 0xdf, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0x50, + 0x0, 0x0, 0xaf, 0xf3, 0x0, 0x0, 0x7b, 0xef, + 0xea, 0x40, 0x0, 0x9, 0xff, 0x30, 0x0, 0x4f, + 0xf5, 0x0, 0x3, 0xef, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0xc, 0xfc, 0x0, 0xc, 0xfb, 0x0, 0x2, + 0xff, 0xe6, 0x10, 0x28, 0xff, 0x90, 0x0, 0x2f, + 0xf5, 0x3, 0xff, 0x20, 0x0, 0xcf, 0xe1, 0x0, + 0x0, 0x6, 0xff, 0x20, 0x0, 0xaf, 0xb0, 0x8f, + 0xc0, 0x0, 0x3f, 0xf6, 0x0, 0x0, 0x0, 0x8, + 0x61, 0x0, 0x4, 0xff, 0x1c, 0xf7, 0x0, 0x7, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xf4, 0xef, 0x50, 0x0, 0x9f, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0x6f, + 0xf3, 0x0, 0xa, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xf7, 0xff, 0x40, 0x0, + 0x9f, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0x7d, 0xf5, 0x0, 0x7, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x21, 0x0, 0x0, 0xd, 0xf6, + 0xbf, 0x80, 0x0, 0x2f, 0xf4, 0x0, 0x0, 0x0, + 0xd, 0xf7, 0x0, 0x0, 0xff, 0x47, 0xfd, 0x0, + 0x0, 0xcf, 0xd1, 0x0, 0x0, 0x8, 0xff, 0x30, + 0x0, 0x4f, 0xf0, 0x2f, 0xf3, 0x0, 0x2, 0xff, + 0xd5, 0x10, 0x3a, 0xff, 0xa0, 0x0, 0xb, 0xfa, + 0x0, 0xbf, 0xc0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0x4, 0xff, 0x30, 0x2, 0xff, + 0x80, 0x0, 0x1, 0x8d, 0xff, 0xfb, 0x40, 0x0, + 0x1, 0xef, 0xa0, 0x0, 0x8, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xe1, + 0x0, 0x0, 0xa, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xdf, 0xf3, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xc4, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xe4, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xfd, 0x85, 0x43, 0x46, 0xaf, 0xff, 0xd2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x26, 0xbd, 0xef, 0xec, 0x94, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00AA "ª" */ + 0x0, 0x6, 0xcf, 0xfb, 0x40, 0xbf, 0xd0, 0xb, + 0xff, 0xff, 0xff, 0x7f, 0xf8, 0x8, 0xff, 0xa1, + 0x4, 0xef, 0xff, 0x40, 0xff, 0xe0, 0x0, 0x5, + 0xff, 0xf0, 0x4f, 0xf8, 0x0, 0x0, 0xe, 0xfd, + 0x6, 0xff, 0x50, 0x0, 0x0, 0xcf, 0xa0, 0x7f, + 0xf4, 0x0, 0x0, 0xb, 0xf7, 0x6, 0xff, 0x50, + 0x0, 0x0, 0xdf, 0xa0, 0x3f, 0xf8, 0x0, 0x0, + 0xf, 0xfd, 0x0, 0xef, 0xd0, 0x0, 0x7, 0xff, + 0xf1, 0x7, 0xff, 0x91, 0x5, 0xff, 0xff, 0x50, + 0xb, 0xff, 0xff, 0xff, 0x7e, 0xfa, 0x0, 0x7, + 0xdf, 0xfc, 0x50, 0x58, 0x70, + + /* U+00AB "«" */ + 0x0, 0x0, 0x4, 0xff, 0x50, 0x0, 0x7f, 0xf3, + 0x0, 0x0, 0x1e, 0xfc, 0x0, 0x3, 0xff, 0xa0, + 0x0, 0x0, 0xbf, 0xf3, 0x0, 0xd, 0xff, 0x10, + 0x0, 0x6, 0xff, 0xa0, 0x0, 0x9f, 0xf7, 0x0, + 0x0, 0x2f, 0xff, 0x10, 0x4, 0xff, 0xd0, 0x0, + 0x0, 0xcf, 0xf8, 0x0, 0x1e, 0xff, 0x50, 0x0, + 0x8, 0xff, 0xe0, 0x0, 0xaf, 0xfb, 0x0, 0x0, + 0x3f, 0xff, 0x50, 0x5, 0xff, 0xf2, 0x0, 0x0, + 0x3f, 0xff, 0x50, 0x5, 0xff, 0xf2, 0x0, 0x0, + 0x8, 0xff, 0xd0, 0x0, 0xaf, 0xfb, 0x0, 0x0, + 0x0, 0xcf, 0xf7, 0x0, 0x1e, 0xff, 0x40, 0x0, + 0x0, 0x2f, 0xff, 0x10, 0x4, 0xff, 0xd0, 0x0, + 0x0, 0x6, 0xff, 0x90, 0x0, 0x9f, 0xf7, 0x0, + 0x0, 0x0, 0xbf, 0xf2, 0x0, 0xd, 0xff, 0x10, + 0x0, 0x0, 0x1e, 0xfb, 0x0, 0x3, 0xff, 0x90, + 0x0, 0x0, 0x5, 0xff, 0x40, 0x0, 0x8f, 0xf3, + + /* U+00AC "¬" */ + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x78, 0x80, + + /* U+00AD "­" */ + 0x22, 0x22, 0x22, 0x22, 0x22, 0xdf, 0xff, 0xff, + 0xff, 0xfd, 0xdf, 0xff, 0xff, 0xff, 0xfd, 0xdf, + 0xff, 0xff, 0xff, 0xfd, + + /* U+00AE "®" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x22, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0x9d, 0xff, 0xff, 0xfc, 0x72, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5d, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xbf, 0xff, 0xa5, 0x21, 0x1, + 0x48, 0xdf, 0xfe, 0x40, 0x0, 0x0, 0x0, 0x1, + 0xdf, 0xfa, 0x10, 0x0, 0x0, 0x0, 0x0, 0x5d, + 0xff, 0x60, 0x0, 0x0, 0x0, 0xdf, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0x50, + 0x0, 0x0, 0xaf, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0x30, 0x0, 0x4f, + 0xf5, 0x0, 0x8f, 0xff, 0xff, 0xfe, 0xb5, 0x0, + 0x0, 0xc, 0xfc, 0x0, 0xc, 0xfb, 0x0, 0x8, + 0xff, 0xee, 0xef, 0xff, 0xf8, 0x0, 0x0, 0x2f, + 0xf5, 0x3, 0xff, 0x20, 0x0, 0x8f, 0xc0, 0x0, + 0x2, 0xbf, 0xf2, 0x0, 0x0, 0xaf, 0xb0, 0x8f, + 0xc0, 0x0, 0x8, 0xfc, 0x0, 0x0, 0x1, 0xff, + 0x60, 0x0, 0x4, 0xff, 0x1c, 0xf7, 0x0, 0x0, + 0x8f, 0xc0, 0x0, 0x0, 0x1f, 0xf5, 0x0, 0x0, + 0xf, 0xf4, 0xef, 0x50, 0x0, 0x8, 0xfc, 0x0, + 0x0, 0x3c, 0xfe, 0x0, 0x0, 0x0, 0xcf, 0x6f, + 0xf3, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xfe, + 0x30, 0x0, 0x0, 0xb, 0xf7, 0xff, 0x40, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xd6, 0x10, 0x0, 0x0, + 0x0, 0xbf, 0x7d, 0xf5, 0x0, 0x0, 0x8f, 0xc0, + 0x4, 0xef, 0x80, 0x0, 0x0, 0x0, 0xd, 0xf6, + 0xbf, 0x80, 0x0, 0x8, 0xfc, 0x0, 0x2, 0xff, + 0x70, 0x0, 0x0, 0x0, 0xff, 0x47, 0xfd, 0x0, + 0x0, 0x8f, 0xc0, 0x0, 0x7, 0xff, 0x30, 0x0, + 0x0, 0x4f, 0xf0, 0x2f, 0xf3, 0x0, 0x8, 0xfc, + 0x0, 0x0, 0xd, 0xfd, 0x0, 0x0, 0xb, 0xfa, + 0x0, 0xbf, 0xc0, 0x0, 0x8f, 0xc0, 0x0, 0x0, + 0x4f, 0xf7, 0x0, 0x4, 0xff, 0x30, 0x2, 0xff, + 0x80, 0x8, 0xfc, 0x0, 0x0, 0x0, 0xbf, 0xf1, + 0x1, 0xef, 0xa0, 0x0, 0x8, 0xff, 0x60, 0x1, + 0x0, 0x0, 0x0, 0x0, 0x11, 0x0, 0xcf, 0xe1, + 0x0, 0x0, 0xa, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xdf, 0xf3, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xc4, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xe4, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xfd, 0x85, 0x43, 0x46, 0xaf, 0xff, 0xd2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x26, 0xbd, 0xef, 0xec, 0x94, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00B0 "°" */ + 0x0, 0x19, 0xdd, 0xb4, 0x0, 0x0, 0x3e, 0xff, + 0xff, 0xf8, 0x0, 0xe, 0xf9, 0x21, 0x6f, 0xf5, + 0x6, 0xfb, 0x0, 0x0, 0x5f, 0xd0, 0x9f, 0x50, + 0x0, 0x0, 0xff, 0xa, 0xf5, 0x0, 0x0, 0xe, + 0xf0, 0x7f, 0xa0, 0x0, 0x4, 0xfd, 0x1, 0xef, + 0x80, 0x4, 0xef, 0x60, 0x4, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x2, 0xae, 0xfc, 0x60, 0x0, + + /* U+00B1 "±" */ + 0x0, 0x0, 0x0, 0xf, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0x0, 0x0, 0x0, 0x0, 0xee, + 0xee, 0xee, 0xef, 0xff, 0xee, 0xee, 0xee, 0xe0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf0, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf0, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, + + /* U+00B2 "²" */ + 0x0, 0x17, 0xce, 0xfe, 0xb4, 0x0, 0x1, 0xdf, + 0xff, 0xff, 0xff, 0x80, 0xb, 0xff, 0x72, 0x15, + 0xff, 0xf1, 0xd, 0xfa, 0x0, 0x0, 0x8f, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf2, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x7f, + 0xfe, 0x10, 0x0, 0x0, 0x1b, 0xff, 0xc1, 0x0, + 0x0, 0x3, 0xef, 0xf9, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0x50, 0x0, 0x0, 0x4, 0xff, 0xe4, 0x22, + 0x22, 0x20, 0x1e, 0xff, 0xff, 0xff, 0xff, 0xf6, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xf6, + + /* U+00B3 "³" */ + 0x0, 0x29, 0xdf, 0xfd, 0xa2, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xff, 0x30, 0xc, 0xff, 0x40, 0x7, + 0xff, 0xa0, 0x4, 0x74, 0x0, 0x1, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x2a, 0xff, 0x40, 0x0, 0x0, + 0xd, 0xff, 0xd4, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xfc, 0x20, 0x0, 0x0, 0x0, 0x3, 0xef, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf4, 0x3c, 0xd5, + 0x0, 0x0, 0x9f, 0xf4, 0xe, 0xfe, 0x51, 0x28, + 0xff, 0xf0, 0x4, 0xff, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x29, 0xdf, 0xfd, 0x92, 0x0, + + /* U+00B5 "µ" */ + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf8, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf8, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf8, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf8, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf8, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf8, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf8, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf8, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf8, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf8, + 0x8f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf8, + 0x8f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf8, + 0x8f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf8, + 0x8f, 0xff, 0x20, 0x0, 0x0, 0x2, 0xff, 0xf8, + 0x8f, 0xff, 0xa0, 0x0, 0x0, 0xb, 0xff, 0xf8, + 0x8f, 0xff, 0xfa, 0x10, 0x2, 0xbf, 0xff, 0xf8, + 0x8f, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xdf, 0xf8, + 0x8f, 0xf9, 0xbf, 0xff, 0xff, 0xfc, 0x5f, 0xf8, + 0x8f, 0xf9, 0x6, 0xcf, 0xfc, 0x70, 0x4f, 0xf8, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00B6 "¶" */ + 0x0, 0x0, 0x6, 0xae, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x5e, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0x0, 0x2, 0xff, + 0xd0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x2f, 0xfd, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xff, 0xff, 0x0, 0x2, 0xff, 0xd0, 0x0, 0xf, + 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x2f, 0xfd, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, + 0x2, 0xff, 0xd0, 0x0, 0xf, 0xff, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x2f, 0xfd, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0x0, 0x2, 0xff, 0xd0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x2f, 0xfd, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, + 0xff, 0x0, 0x2, 0xff, 0xd0, 0x0, 0x0, 0x2e, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x2f, 0xfd, 0x0, + 0x0, 0x0, 0x2b, 0xff, 0xff, 0xff, 0x0, 0x2, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x1, 0x57, 0xff, + 0xf0, 0x0, 0x2f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0x0, 0x2, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf0, 0x0, 0x2f, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0x0, 0x2, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf0, 0x0, 0x2f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x0, 0x2, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf0, + 0x0, 0x2f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0x0, 0x2, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xf0, 0x0, 0x2f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x0, + 0x2, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf0, 0x0, 0x2f, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0x0, 0x2, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf0, 0x0, + 0x2f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x0, 0x2, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf0, 0x0, 0x2f, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x0, 0x2, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf0, 0x0, 0x2f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0x0, 0x2, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf0, 0x0, 0x2f, + 0xfd, 0x0, 0x0, + + /* U+00B7 "·" */ + 0x79, 0x97, 0xcf, 0xfd, 0xcf, 0xfd, 0xcf, 0xfd, + + /* U+00BB "»" */ + 0x3f, 0xf7, 0x0, 0x5, 0xff, 0x40, 0x0, 0x0, + 0xa, 0xff, 0x30, 0x0, 0xcf, 0xe1, 0x0, 0x0, + 0x1, 0xff, 0xd0, 0x0, 0x3f, 0xfb, 0x0, 0x0, + 0x0, 0x7f, 0xf9, 0x0, 0xa, 0xff, 0x60, 0x0, + 0x0, 0xd, 0xff, 0x40, 0x1, 0xff, 0xf2, 0x0, + 0x0, 0x4, 0xff, 0xe1, 0x0, 0x7f, 0xfc, 0x0, + 0x0, 0x0, 0xbf, 0xfa, 0x0, 0xe, 0xff, 0x80, + 0x0, 0x0, 0x2f, 0xff, 0x50, 0x5, 0xff, 0xf3, + 0x0, 0x0, 0x2f, 0xff, 0x50, 0x4, 0xff, 0xf4, + 0x0, 0x0, 0xaf, 0xfa, 0x0, 0xd, 0xff, 0x80, + 0x0, 0x4, 0xff, 0xe1, 0x0, 0x7f, 0xfd, 0x0, + 0x0, 0xd, 0xff, 0x40, 0x1, 0xef, 0xf2, 0x0, + 0x0, 0x6f, 0xf9, 0x0, 0x9, 0xff, 0x70, 0x0, + 0x1, 0xef, 0xd0, 0x0, 0x2f, 0xfb, 0x0, 0x0, + 0x9, 0xff, 0x30, 0x0, 0xbf, 0xe1, 0x0, 0x0, + 0x3f, 0xf8, 0x0, 0x4, 0xff, 0x50, 0x0, 0x0, + + /* U+00BD "½" */ + 0x0, 0x0, 0x1e, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xc0, 0x0, 0x0, 0x0, + 0x2d, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xf2, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xf5, 0x0, 0x0, 0x1, 0xdf, 0xfd, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xfa, 0x0, + 0x0, 0x0, 0x2f, 0xe6, 0x3f, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xfe, 0x10, 0x0, 0x0, + 0x1, 0x50, 0x3, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x5f, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xf6, 0x0, 0x0, 0x0, + 0x1e, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0x60, 0x0, 0x0, 0xb, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xf6, 0x0, 0x0, 0x6, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x44, + 0x10, 0x0, 0x2, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xd0, 0x0, 0x1, 0x8e, 0xff, 0xfc, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xf3, 0x0, 0x2, 0xef, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf8, 0x0, + 0x0, 0xbf, 0xf6, 0x10, 0x4e, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xfc, 0x0, 0x0, 0xc, + 0xea, 0x0, 0x0, 0x8f, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0x20, 0x0, 0x0, 0x0, 0x5, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1b, 0xff, 0xc1, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3e, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0xd, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xfe, 0x42, + 0x22, 0x22, 0x0, 0x0, 0x9, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x4, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x68, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0384 "΄" */ + 0x0, 0xd, 0xee, 0xd1, 0x0, 0x6f, 0xff, 0x40, + 0x0, 0xef, 0xf7, 0x0, 0x6, 0xff, 0xb0, 0x0, + 0xd, 0xfd, 0x0, 0x0, + + /* U+0386 "Ά" */ + 0x0, 0x0, 0xef, 0xfe, 0x10, 0x5f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xf4, 0x0, 0xbf, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0x70, 0x1, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfa, 0x0, 0x7, 0xff, 0x9f, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbe, 0xc0, 0x0, + 0xd, 0xff, 0x3c, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfe, 0x7, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf9, 0x1, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf4, 0x0, 0xbf, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xe0, 0x0, 0x5f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0x80, 0x0, 0xf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x20, + 0x0, 0x9, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xfc, 0x0, 0x0, 0x3, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xf7, 0x0, 0x0, 0x0, 0xdf, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xdc, + 0xcc, 0xcc, 0xcc, 0xcf, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0x10, 0x0, 0x0, + 0x8, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x70, 0x0, 0x0, 0xe, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xd0, + 0x0, 0x0, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf4, 0x0, 0x0, 0xaf, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xfa, 0x0, 0x1, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x10, + 0x7, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x70, 0xd, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xe0, + + /* U+0388 "Έ" */ + 0x0, 0x7f, 0xff, 0x80, 0xf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, 0xe, + 0xff, 0xb0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb0, 0x6, 0xff, 0xd1, + 0x0, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x0, 0xef, 0xf3, 0x0, 0x0, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4e, 0xe5, 0x0, 0x0, 0xf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf4, + + /* U+0389 "Ή" */ + 0x0, 0x7f, 0xff, 0x80, 0xaf, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0x80, 0xe, + 0xff, 0xb0, 0xa, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf8, 0x6, 0xff, 0xe1, + 0x0, 0xaf, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0x80, 0xdf, 0xf3, 0x0, 0xa, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xf8, 0x4e, 0xe6, 0x0, 0x0, 0xaf, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0x80, 0x0, 0x0, 0x0, 0xa, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0x80, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x80, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0x80, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0x80, 0x0, 0x0, 0x0, 0xa, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0x80, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0x80, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0x80, 0x0, 0x0, 0x0, 0xa, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0x80, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x80, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xf8, + + /* U+038A "Ί" */ + 0x0, 0x7f, 0xff, 0x80, 0xaf, 0xfb, 0x0, 0xef, + 0xfb, 0x0, 0xaf, 0xfb, 0x6, 0xff, 0xe1, 0x0, + 0xaf, 0xfb, 0xd, 0xff, 0x30, 0x0, 0xaf, 0xfb, + 0x4e, 0xe6, 0x0, 0x0, 0xaf, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xfb, + + /* U+038C "Ό" */ + 0x0, 0x7f, 0xff, 0x80, 0x0, 0x4, 0x8c, 0xef, + 0xfd, 0xb7, 0x30, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xb0, 0x0, 0x5d, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xb3, 0x0, 0x0, 0x0, 0x6, 0xff, 0xd1, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0xef, 0xf3, 0x1, 0xdf, + 0xff, 0xf8, 0x40, 0x0, 0x15, 0xaf, 0xff, 0xf9, + 0x0, 0x0, 0x4e, 0xe5, 0x0, 0xbf, 0xff, 0xb1, + 0x0, 0x0, 0x0, 0x0, 0x3d, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1d, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xb0, 0x0, 0x0, 0x7, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0x30, 0x0, 0x0, 0xcf, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xf8, 0x0, 0x0, 0xf, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xc0, 0x0, 0x3, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x0, + 0x0, 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf1, 0x0, 0x6, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x20, 0x0, 0x7f, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf2, 0x0, 0x6, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x10, 0x0, 0x4f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, + 0x0, 0x1, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfc, 0x0, 0x0, + 0xc, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x80, 0x0, 0x0, 0x7f, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xf3, 0x0, 0x0, 0x1, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xcf, 0xff, 0x30, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xfa, 0x10, 0x0, + 0x0, 0x0, 0x2, 0xdf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x1d, 0xff, 0xfe, 0x83, 0x0, 0x0, + 0x4a, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x49, 0xce, 0xff, 0xdb, 0x72, 0x0, 0x0, 0x0, + 0x0, + + /* U+038E "Ύ" */ + 0x0, 0x7f, 0xff, 0x80, 0x1e, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xfe, + 0x10, 0xe, 0xff, 0xb0, 0x0, 0x5f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x40, 0x6, 0xff, 0xd1, 0x0, 0x0, 0xaf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x90, 0x0, 0xef, 0xf3, 0x0, 0x0, 0x1, 0xef, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xd0, 0x0, 0x4e, 0xe5, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xf1, 0x0, 0x0, 0x0, 0xef, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xb0, 0x0, 0x0, 0x9f, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0x50, 0x0, 0x3f, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xfe, 0x0, 0xd, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, 0x7, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf4, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+038F "Ώ" */ + 0x0, 0x7f, 0xff, 0x80, 0x0, 0x4, 0x9c, 0xef, + 0xfe, 0xb7, 0x10, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xfb, 0x0, 0x5, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x6, 0xff, 0xd1, 0x0, + 0xaf, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xd2, + 0x0, 0x0, 0xe, 0xff, 0x30, 0xb, 0xff, 0xff, + 0x93, 0x0, 0x2, 0x7e, 0xff, 0xfe, 0x10, 0x0, + 0x4e, 0xe5, 0x0, 0x8f, 0xff, 0xe3, 0x0, 0x0, + 0x0, 0x1, 0xbf, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xfe, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x60, + 0x0, 0x0, 0x6f, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xa0, 0x0, 0x0, + 0x9f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xe0, 0x0, 0x0, 0xbf, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xf0, 0x0, 0x0, 0xcf, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf1, + 0x0, 0x0, 0xdf, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf1, 0x0, 0x0, + 0xcf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xf0, 0x0, 0x0, 0xaf, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xe0, 0x0, 0x0, 0x6f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xb0, + 0x0, 0x0, 0x2f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0x60, 0x0, 0x0, + 0xb, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0x10, 0x0, 0x0, 0x4, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x1d, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xef, 0xf6, 0x0, 0x0, 0x0, 0x2, + 0xdf, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2e, 0xff, 0xa1, 0x0, 0x0, 0x7f, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xf6, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x0, + 0xa, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xff, 0xf6, + + /* U+0390 "ΐ" */ + 0x0, 0x0, 0x0, 0x7, 0x88, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xfa, 0x0, 0x0, 0x6f, 0xfa, + 0x0, 0xdf, 0xd0, 0xaf, 0xf6, 0x6f, 0xfa, 0x5, + 0xff, 0x30, 0xaf, 0xf6, 0x6f, 0xfa, 0xc, 0xf7, + 0x0, 0xaf, 0xf6, 0x25, 0x53, 0x5, 0x50, 0x0, + 0x35, 0x52, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0x90, 0x0, 0x0, + + /* U+0391 "Α" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0x9f, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x3c, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfe, 0x7, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf9, 0x1, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf4, 0x0, 0xcf, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xe0, 0x0, 0x6f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0x80, 0x0, 0xf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x30, + 0x0, 0xa, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xfd, 0x0, 0x0, 0x4, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xf7, 0x0, 0x0, 0x0, 0xdf, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xdc, + 0xcc, 0xcc, 0xcc, 0xcf, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0x10, 0x0, 0x0, + 0x8, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x70, 0x0, 0x0, 0xe, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xd0, + 0x0, 0x0, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf4, 0x0, 0x0, 0xaf, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xfa, 0x0, 0x1, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x10, + 0x7, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x70, 0xd, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xe0, + + /* U+0392 "Β" */ + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xda, 0x50, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe4, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x5, + 0xff, 0xf1, 0x0, 0x0, 0x1, 0x25, 0xaf, 0xff, + 0xf1, 0x0, 0x5f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x70, 0x5, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfb, 0x0, 0x5f, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xd0, 0x5, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xfc, 0x0, 0x5f, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0x90, 0x5, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf2, + 0x0, 0x5f, 0xff, 0x10, 0x0, 0x0, 0x1, 0x49, + 0xff, 0xf7, 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x40, 0x0, + 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x5f, 0xff, 0x10, 0x0, 0x0, + 0x1, 0x37, 0xdf, 0xff, 0xc0, 0x5, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x60, + 0x5f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xfc, 0x5, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xf0, 0x5f, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x15, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xf0, 0x5f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xfd, 0x5, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x80, 0x5f, + 0xff, 0x10, 0x0, 0x0, 0x1, 0x26, 0xcf, 0xff, + 0xe1, 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd3, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0xc8, 0x40, 0x0, + 0x0, + + /* U+0393 "Γ" */ + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf1, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0394 "Δ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0x9f, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x3d, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfe, 0x7, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf9, 0x2, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf4, 0x0, 0xcf, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xe0, 0x0, 0x6f, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0x90, 0x0, 0x1f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x30, + 0x0, 0xa, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xfd, 0x0, 0x0, 0x4, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xf7, 0x0, 0x0, 0x0, 0xef, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0x10, 0x0, 0x0, + 0x8, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x70, 0x0, 0x0, 0xe, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xd0, + 0x0, 0x0, 0x5f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xf4, 0x0, 0x0, 0xbf, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xfa, 0x0, 0x1, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x10, + 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x70, 0xd, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd0, + + /* U+0395 "Ε" */ + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf7, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x70, 0x2f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x2, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x2f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x2f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf1, 0x2f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x12, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf1, + + /* U+0396 "Ζ" */ + 0x0, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x90, 0x0, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xdf, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2e, 0xff, 0xe2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf0, 0x5f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, + + /* U+0397 "Η" */ + 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf1, 0x1f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf1, 0x1f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xf1, 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf1, 0x1f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf1, 0x1f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf1, 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xf1, 0x1f, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf1, + 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf1, 0x1f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf1, 0x1f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xf1, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf1, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0x1f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf1, 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xf1, 0x1f, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf1, + 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf1, 0x1f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf1, 0x1f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xf1, 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf1, 0x1f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf1, 0x1f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf1, 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xf1, 0x1f, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf1, + 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf1, 0x1f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf1, + + /* U+0398 "Θ" */ + 0x0, 0x0, 0x0, 0x0, 0x38, 0xcd, 0xff, 0xdc, + 0x83, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xf9, 0x41, 0x0, 0x4, 0x9f, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfc, + 0x20, 0x0, 0x0, 0x0, 0x2, 0xcf, 0xff, 0x90, + 0x0, 0x0, 0x5f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf5, 0x0, 0x0, 0xdf, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xfd, 0x0, 0x5, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x50, + 0xa, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xa0, 0xe, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xe0, 0x1f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf1, 0x2f, + 0xff, 0x50, 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x10, 0x4, 0xff, 0xf3, 0x4f, 0xff, 0x40, 0x1, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x10, 0x3, 0xff, + 0xf4, 0x4f, 0xff, 0x30, 0x1, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x10, 0x3, 0xff, 0xf4, 0x4f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xf3, 0x1f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf2, + 0xe, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xe0, 0xa, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xa0, 0x5, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x50, 0x0, + 0xef, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xfd, 0x0, 0x0, 0x5f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf5, + 0x0, 0x0, 0xa, 0xff, 0xfc, 0x10, 0x0, 0x0, + 0x0, 0x1, 0xcf, 0xff, 0x90, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf9, 0x40, 0x0, 0x4, 0x9f, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4c, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x38, 0xce, 0xff, 0xec, 0x83, 0x0, 0x0, + 0x0, 0x0, + + /* U+0399 "Ι" */ + 0xbf, 0xfb, 0xbf, 0xfb, 0xbf, 0xfb, 0xbf, 0xfb, + 0xbf, 0xfb, 0xbf, 0xfb, 0xbf, 0xfb, 0xbf, 0xfb, + 0xbf, 0xfb, 0xbf, 0xfb, 0xbf, 0xfb, 0xbf, 0xfb, + 0xbf, 0xfb, 0xbf, 0xfb, 0xbf, 0xfb, 0xbf, 0xfb, + 0xbf, 0xfb, 0xbf, 0xfb, 0xbf, 0xfb, 0xbf, 0xfb, + 0xbf, 0xfb, 0xbf, 0xfb, 0xbf, 0xfb, 0xbf, 0xfb, + 0xbf, 0xfb, 0xbf, 0xfb, + + /* U+039A "Κ" */ + 0x5f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xd1, 0x5f, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xfd, 0x10, 0x5f, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xd1, + 0x0, 0x5f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xfc, 0x10, 0x0, 0x5f, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xc1, 0x0, 0x0, 0x5f, + 0xff, 0x10, 0x0, 0x0, 0x9, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x10, 0x0, 0x0, 0x9f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x10, + 0x0, 0x9, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x10, 0x0, 0x9f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x10, 0x9, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x10, 0x8f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x18, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x9f, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xf9, 0x4f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0x90, 0x9, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf9, + 0x0, 0x0, 0xdf, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x80, 0x0, 0x0, 0x3f, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x10, 0x0, 0x0, + 0x7, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x10, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x70, 0x0, + 0x0, 0x5f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xf3, 0x0, 0x0, 0x5f, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xfe, 0x10, 0x0, 0x5f, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xa0, 0x0, 0x5f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xf6, 0x0, 0x5f, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x20, + 0x5f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xd0, 0x5f, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf9, + + /* U+039B "Λ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xfc, 0xdf, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf7, 0x8f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xf2, 0x3f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xd0, 0xd, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0x80, 0x8, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x20, 0x2, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xfc, 0x0, 0x0, 0xcf, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xf6, 0x0, 0x0, 0x7f, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf0, 0x0, 0x0, 0x1f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xa0, 0x0, 0x0, 0xb, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0x40, 0x0, 0x0, 0x6, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfb, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x10, 0x0, 0x0, 0x8, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0x80, 0x0, + 0x0, 0xe, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xe0, 0x0, 0x0, 0x4f, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf4, 0x0, + 0x0, 0xaf, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xfa, 0x0, 0x1, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x10, + 0x7, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0x60, 0xd, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xc0, + 0x3f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf3, 0x9f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf9, + + /* U+039C "Μ" */ + 0x4f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xf4, 0x4f, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xf4, 0x4f, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf4, 0x4f, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf4, 0x4f, 0xff, 0xcf, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xfe, 0xff, + 0xf4, 0x4f, 0xff, 0x7f, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xf9, 0xff, 0xf4, 0x4f, 0xff, + 0x1f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xf3, 0xff, 0xf4, 0x4f, 0xff, 0xc, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xe0, 0xff, 0xf4, + 0x4f, 0xff, 0x7, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0x80, 0xff, 0xf4, 0x4f, 0xff, 0x1, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x30, + 0xff, 0xf4, 0x4f, 0xff, 0x0, 0xcf, 0xf5, 0x0, + 0x0, 0x0, 0xd, 0xfd, 0x0, 0xff, 0xf4, 0x4f, + 0xff, 0x0, 0x6f, 0xfa, 0x0, 0x0, 0x0, 0x3f, + 0xf8, 0x0, 0xff, 0xf4, 0x4f, 0xff, 0x0, 0x1f, + 0xff, 0x0, 0x0, 0x0, 0x8f, 0xf2, 0x0, 0xff, + 0xf4, 0x4f, 0xff, 0x0, 0xc, 0xff, 0x40, 0x0, + 0x0, 0xef, 0xd0, 0x0, 0xff, 0xf4, 0x4f, 0xff, + 0x0, 0x6, 0xff, 0xa0, 0x0, 0x3, 0xff, 0x70, + 0x0, 0xff, 0xf4, 0x4f, 0xff, 0x0, 0x1, 0xff, + 0xf0, 0x0, 0x9, 0xff, 0x20, 0x0, 0xff, 0xf4, + 0x4f, 0xff, 0x0, 0x0, 0xbf, 0xf4, 0x0, 0xe, + 0xfc, 0x0, 0x0, 0xff, 0xf4, 0x4f, 0xff, 0x0, + 0x0, 0x6f, 0xfa, 0x0, 0x4f, 0xf7, 0x0, 0x0, + 0xff, 0xf4, 0x4f, 0xff, 0x0, 0x0, 0x1f, 0xff, + 0x0, 0x9f, 0xf1, 0x0, 0x0, 0xff, 0xf4, 0x4f, + 0xff, 0x0, 0x0, 0xb, 0xff, 0x40, 0xef, 0xc0, + 0x0, 0x0, 0xff, 0xf4, 0x4f, 0xff, 0x0, 0x0, + 0x6, 0xff, 0x94, 0xff, 0x60, 0x0, 0x0, 0xff, + 0xf4, 0x4f, 0xff, 0x0, 0x0, 0x1, 0xff, 0xe9, + 0xff, 0x10, 0x0, 0x0, 0xff, 0xf4, 0x4f, 0xff, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0xff, 0xf4, 0x4f, 0xff, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0xff, 0xf4, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0xff, 0xf4, 0x4f, 0xff, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0xff, 0xf4, + + /* U+039D "Ν" */ + 0x2f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf2, 0x2f, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf2, 0x2f, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xf2, 0x2f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xf2, 0x2f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf2, 0x2f, + 0xff, 0xef, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf2, 0x2f, 0xff, 0x6f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xf2, 0x2f, 0xff, 0x29, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf2, + 0x2f, 0xff, 0x20, 0xef, 0xfe, 0x10, 0x0, 0x0, + 0x2, 0xff, 0xf2, 0x2f, 0xff, 0x20, 0x4f, 0xff, + 0xa0, 0x0, 0x0, 0x2, 0xff, 0xf2, 0x2f, 0xff, + 0x20, 0x9, 0xff, 0xf4, 0x0, 0x0, 0x2, 0xff, + 0xf2, 0x2f, 0xff, 0x20, 0x0, 0xef, 0xfe, 0x10, + 0x0, 0x2, 0xff, 0xf2, 0x2f, 0xff, 0x20, 0x0, + 0x4f, 0xff, 0xa0, 0x0, 0x2, 0xff, 0xf2, 0x2f, + 0xff, 0x20, 0x0, 0x9, 0xff, 0xf4, 0x0, 0x2, + 0xff, 0xf2, 0x2f, 0xff, 0x20, 0x0, 0x1, 0xef, + 0xfe, 0x10, 0x2, 0xff, 0xf2, 0x2f, 0xff, 0x20, + 0x0, 0x0, 0x4f, 0xff, 0x90, 0x2, 0xff, 0xf2, + 0x2f, 0xff, 0x20, 0x0, 0x0, 0xa, 0xff, 0xf4, + 0x2, 0xff, 0xf2, 0x2f, 0xff, 0x20, 0x0, 0x0, + 0x1, 0xef, 0xfe, 0x2, 0xff, 0xf2, 0x2f, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x92, 0xff, + 0xf2, 0x2f, 0xff, 0x20, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf6, 0xff, 0xf2, 0x2f, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xf2, 0x2f, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xf2, 0x2f, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xf2, 0x2f, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xf2, + 0x2f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xf2, 0x2f, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf2, + + /* U+039E "Ξ" */ + 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf0, 0x9, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf7, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x71, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf7, + + /* U+039F "Ο" */ + 0x0, 0x0, 0x0, 0x0, 0x38, 0xcd, 0xff, 0xdc, + 0x83, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xf9, 0x41, 0x0, 0x4, 0x9f, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfc, + 0x20, 0x0, 0x0, 0x0, 0x2, 0xcf, 0xff, 0x90, + 0x0, 0x0, 0x5f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf5, 0x0, 0x0, 0xdf, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xfd, 0x0, 0x5, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x50, + 0xa, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xa0, 0xe, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xe0, 0x1f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf1, 0x2f, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf3, 0x4f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf4, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf4, 0x4f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xf3, 0x1f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf2, + 0xe, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xe0, 0xa, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xa0, 0x5, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x50, 0x0, + 0xef, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xfd, 0x0, 0x0, 0x5f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf5, + 0x0, 0x0, 0xa, 0xff, 0xfc, 0x10, 0x0, 0x0, + 0x0, 0x1, 0xcf, 0xff, 0x90, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf9, 0x40, 0x0, 0x4, 0x9f, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4c, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x38, 0xce, 0xff, 0xec, 0x83, 0x0, 0x0, + 0x0, 0x0, + + /* U+03A0 "Π" */ + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf1, 0x1f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0x1f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf1, 0x1f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf1, 0x1f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf1, 0x1f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf1, 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xf1, 0x1f, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf1, + 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf1, 0x1f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf1, 0x1f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xf1, 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf1, 0x1f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf1, 0x1f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf1, 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xf1, 0x1f, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf1, + 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf1, 0x1f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf1, 0x1f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xf1, 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf1, 0x1f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf1, 0x1f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf1, 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xf1, 0x1f, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf1, + 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf1, 0x1f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf1, + + /* U+03A1 "Ρ" */ + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xed, 0xb7, + 0x20, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x3, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x1, 0x38, 0xff, + 0xff, 0x50, 0x3f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xfd, 0x3, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf2, 0x3f, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x53, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xf6, 0x3f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x63, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xf4, 0x3f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0x3, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xa0, 0x3f, 0xff, + 0x30, 0x0, 0x0, 0x1, 0x25, 0xbf, 0xff, 0xf2, + 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe4, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0xc9, 0x50, 0x0, 0x0, + 0x3f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+03A3 "Σ" */ + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x26, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf2, 0x6f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x23, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, 0xfe, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x6f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd6, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + + /* U+03A4 "Τ" */ + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf3, 0x3f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A5 "Υ" */ + 0x9f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf6, 0xd, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xb0, + 0x3, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xfe, 0x10, 0x0, 0x9f, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf5, 0x0, + 0x0, 0xd, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xa0, 0x0, 0x0, 0x4, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x70, 0x0, 0x0, 0x7, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xf2, 0x0, 0x0, 0x2f, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xfb, 0x0, 0x0, 0xcf, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x50, 0x6, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xe0, 0x1e, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf8, 0x9f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A6 "Φ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x55, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x17, 0xbd, 0xff, 0xff, 0xff, 0xed, 0x95, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x80, 0x0, + 0x0, 0x0, 0x3, 0xef, 0xff, 0xff, 0xee, 0xff, + 0xfd, 0xef, 0xff, 0xff, 0xc1, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xb4, 0x0, 0x5f, 0xff, 0x10, 0x16, + 0xdf, 0xff, 0xd1, 0x0, 0x0, 0xdf, 0xff, 0x50, + 0x0, 0x5, 0xff, 0xf1, 0x0, 0x0, 0x9f, 0xff, + 0xb0, 0x0, 0x7f, 0xff, 0x50, 0x0, 0x0, 0x5f, + 0xff, 0x10, 0x0, 0x0, 0xaf, 0xff, 0x30, 0xd, + 0xff, 0xc0, 0x0, 0x0, 0x5, 0xff, 0xf1, 0x0, + 0x0, 0x1, 0xff, 0xfa, 0x2, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x10, 0x0, 0x0, 0xa, + 0xff, 0xe0, 0x5f, 0xff, 0x20, 0x0, 0x0, 0x5, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x17, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x10, + 0x0, 0x0, 0x4, 0xff, 0xf3, 0x7f, 0xff, 0x10, + 0x0, 0x0, 0x5, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x26, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x10, 0x0, 0x0, 0x6, 0xff, 0xf1, + 0x3f, 0xff, 0x60, 0x0, 0x0, 0x5, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x9f, 0xfe, 0x0, 0xef, 0xfc, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x10, 0x0, 0x0, + 0x1e, 0xff, 0x90, 0x7, 0xff, 0xf6, 0x0, 0x0, + 0x5, 0xff, 0xf1, 0x0, 0x0, 0x9, 0xff, 0xf3, + 0x0, 0xe, 0xff, 0xf7, 0x0, 0x0, 0x5f, 0xff, + 0x10, 0x0, 0x9, 0xff, 0xfa, 0x0, 0x0, 0x2f, + 0xff, 0xfc, 0x51, 0x5, 0xff, 0xf1, 0x1, 0x6d, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x3d, 0xff, 0xff, + 0xfe, 0xef, 0xff, 0xde, 0xff, 0xff, 0xfb, 0x10, + 0x0, 0x0, 0x0, 0x19, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x6a, 0xde, 0xff, 0xff, 0xfe, 0xc9, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+03A7 "Χ" */ + 0x4, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xb0, 0x0, 0x9f, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfe, 0x10, + 0x0, 0xd, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xf3, 0x0, 0x0, 0x3, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x80, 0x0, 0x0, 0x1, + 0xef, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf4, 0x0, 0x0, 0xc, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xfe, 0x10, 0x0, 0x8f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xa0, 0x4, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf5, 0x1e, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xfe, 0xaf, 0xfe, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xfa, 0xbf, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xe1, 0x1f, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x50, 0x6, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xf9, 0x0, 0x0, 0xbf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, + 0xd0, 0x0, 0x0, 0x1e, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x30, 0x0, 0x0, 0x4, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x90, 0x0, + 0x0, 0x4f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xf4, 0x0, 0x1, 0xef, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfe, 0x10, + 0xb, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xb0, 0x7f, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf6, + + /* U+03A8 "Ψ" */ + 0xcf, 0xfa, 0x0, 0x0, 0x0, 0xa, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x9f, 0xfd, 0xcf, 0xfa, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x9f, 0xfd, 0xcf, 0xfa, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x9f, 0xfd, 0xcf, + 0xfa, 0x0, 0x0, 0x0, 0xa, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x9f, 0xfd, 0xcf, 0xfa, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x9f, + 0xfd, 0xcf, 0xfa, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x9f, 0xfd, 0xcf, 0xfa, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x9f, 0xfd, 0xcf, 0xfa, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xb0, 0x0, 0x0, 0x0, 0xaf, 0xfd, + 0xbf, 0xfb, 0x0, 0x0, 0x0, 0xa, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0xaf, 0xfc, 0xaf, 0xfd, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0xdf, 0xfb, 0x7f, 0xff, 0x10, 0x0, 0x0, 0xa, + 0xff, 0xb0, 0x0, 0x0, 0x1, 0xff, 0xf8, 0x3f, + 0xff, 0x60, 0x0, 0x0, 0xa, 0xff, 0xb0, 0x0, + 0x0, 0x7, 0xff, 0xf4, 0xd, 0xff, 0xe1, 0x0, + 0x0, 0xa, 0xff, 0xb0, 0x0, 0x0, 0x1e, 0xff, + 0xe0, 0x6, 0xff, 0xfd, 0x20, 0x0, 0xa, 0xff, + 0xb0, 0x0, 0x2, 0xdf, 0xff, 0x70, 0x0, 0xaf, + 0xff, 0xfa, 0x51, 0xa, 0xff, 0xb0, 0x4, 0x9f, + 0xff, 0xfb, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc1, 0x0, + 0x0, 0x0, 0x7e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x59, 0xce, 0xff, 0xff, 0xff, 0xec, 0x95, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+03A9 "Ω" */ + 0x0, 0x0, 0x0, 0x0, 0x5a, 0xdf, 0xff, 0xda, + 0x61, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1c, 0xff, 0xff, 0xff, 0xef, + 0xff, 0xff, 0xfc, 0x10, 0x0, 0x0, 0x0, 0x1d, + 0xff, 0xff, 0x82, 0x0, 0x3, 0x8f, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xfc, 0x10, 0x0, + 0x0, 0x0, 0x2d, 0xff, 0xfa, 0x0, 0x0, 0x5, + 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x1d, + 0xff, 0xf4, 0x0, 0x0, 0xdf, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, 0x0, + 0x4f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0x30, 0x8, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf7, + 0x0, 0xcf, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xb0, 0xe, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xfd, 0x0, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xe0, 0xf, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xfe, 0x0, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xd0, 0xc, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xfb, 0x0, 0x9f, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x80, + 0x4, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf3, 0x0, 0xe, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfd, + 0x0, 0x0, 0x6f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0x50, 0x0, 0x0, 0xcf, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xb0, 0x0, 0x0, 0x2, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x4, 0xef, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf8, + 0x0, 0x0, 0x18, 0xff, 0xe3, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, 0xc, 0xff, + 0xff, 0xff, 0xff, 0xf3, 0x4f, 0xff, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0x34, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, 0xc, + 0xff, 0xff, 0xff, 0xff, 0xf3, + + /* U+03AA "Ϊ" */ + 0xf, 0xff, 0x40, 0x7, 0xff, 0xd0, 0xff, 0xf4, + 0x0, 0x7f, 0xfd, 0xf, 0xff, 0x40, 0x7, 0xff, + 0xd0, 0x99, 0x92, 0x0, 0x49, 0x97, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0xbf, 0xfb, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xb0, 0x0, 0x0, 0x0, 0xbf, 0xfb, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0xbf, 0xfb, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0xbf, 0xfb, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xb0, 0x0, 0x0, 0x0, 0xbf, + 0xfb, 0x0, 0x0, 0x0, 0xb, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0xbf, 0xfb, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0xbf, 0xfb, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0xbf, 0xfb, 0x0, 0x0, 0x0, 0xb, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0xbf, 0xfb, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xb0, 0x0, 0x0, 0x0, 0xbf, 0xfb, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0xbf, 0xfb, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0xbf, 0xfb, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xb0, 0x0, 0x0, 0x0, 0xbf, + 0xfb, 0x0, 0x0, + + /* U+03AB "Ϋ" */ + 0x0, 0x0, 0x0, 0xf, 0xff, 0x40, 0x7, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x40, 0x7, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x40, 0x7, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0x99, 0x20, 0x4, 0x99, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf6, + 0xd, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xb0, 0x3, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfe, 0x10, + 0x0, 0x9f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xf5, 0x0, 0x0, 0xd, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xa0, 0x0, + 0x0, 0x4, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0x70, 0x0, 0x0, 0x7, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf2, 0x0, 0x0, 0x2f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xfb, 0x0, 0x0, 0xcf, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0x50, 0x6, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xe0, 0x1e, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf8, 0x9f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+03AC "ά" */ + 0x0, 0x0, 0x0, 0x0, 0x9, 0xee, 0xe4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x28, 0xdf, + 0xfd, 0x93, 0x0, 0xe, 0xff, 0x40, 0x0, 0x7f, + 0xff, 0xff, 0xff, 0xf7, 0x3, 0xff, 0xf0, 0x0, + 0x8f, 0xff, 0xfc, 0xab, 0xff, 0xf7, 0x7f, 0xfb, + 0x0, 0x4f, 0xff, 0xd2, 0x0, 0x0, 0xaf, 0xfd, + 0xff, 0x70, 0xc, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf3, 0x2, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0x0, 0x6f, 0xff, 0x10, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xc0, 0x9, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf9, 0x0, + 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0x60, 0xb, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xf3, 0x0, 0xaf, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0x50, 0x9, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xf8, 0x0, 0x6f, 0xff, + 0x10, 0x0, 0x0, 0x0, 0xd, 0xff, 0xc0, 0x2, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x0, 0xc, 0xff, 0xe1, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf2, 0x0, 0x3f, 0xff, 0xc1, 0x0, 0x1, + 0xcf, 0xed, 0xff, 0x60, 0x0, 0x7f, 0xff, 0xfb, + 0x9b, 0xff, 0xf7, 0x8f, 0xfa, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xff, 0xf8, 0x3, 0xff, 0xe0, 0x0, + 0x0, 0x28, 0xdf, 0xfd, 0xa3, 0x0, 0xd, 0xff, + 0x40, + + /* U+03AD "έ" */ + 0x0, 0x0, 0x0, 0x9, 0xee, 0xe4, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x7c, 0xef, + 0xec, 0x71, 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, + 0xff, 0xe6, 0x0, 0x0, 0xdf, 0xff, 0xdc, 0xef, + 0xff, 0xf4, 0x0, 0x6f, 0xfe, 0x30, 0x0, 0x4c, + 0xf5, 0x0, 0xa, 0xff, 0x70, 0x0, 0x0, 0x1, + 0x0, 0x0, 0xbf, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xb4, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x4e, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x1, 0xaf, 0xff, 0xff, 0x50, 0x0, 0x0, 0x2, + 0xef, 0xff, 0xda, 0xa3, 0x0, 0x0, 0x0, 0xcf, + 0xfe, 0x30, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x30, + 0x0, 0x0, 0x6, 0x50, 0x0, 0xef, 0xfd, 0x20, + 0x0, 0x19, 0xff, 0x80, 0x6, 0xff, 0xff, 0xba, + 0xbf, 0xff, 0xfa, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x3, 0x9d, 0xff, 0xeb, + 0x71, 0x0, 0x0, + + /* U+03AE "ή" */ + 0x0, 0x0, 0x0, 0x0, 0xde, 0xed, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xd1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf4, 0x1, 0x7c, 0xef, 0xda, 0x40, 0x0, + 0x9f, 0xf4, 0x4e, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x9f, 0xf8, 0xff, 0xfd, 0xcd, 0xff, 0xff, 0xa0, + 0x9f, 0xff, 0xfb, 0x20, 0x0, 0x2d, 0xff, 0xf2, + 0x9f, 0xff, 0xa0, 0x0, 0x0, 0x2, 0xff, 0xf6, + 0x9f, 0xff, 0x20, 0x0, 0x0, 0x0, 0xcf, 0xf8, + 0x9f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf9, + 0x9f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x9f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + + /* U+03AF "ί" */ + 0x0, 0x1f, 0xff, 0xe1, 0x0, 0x8f, 0xff, 0x30, + 0x0, 0xef, 0xf6, 0x0, 0x7, 0xff, 0x90, 0x0, + 0xc, 0xeb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0x90, 0x0, + 0x9, 0xff, 0x90, 0x0, 0x9, 0xff, 0x90, 0x0, + 0x9, 0xff, 0x90, 0x0, 0x9, 0xff, 0x90, 0x0, + 0x9, 0xff, 0x90, 0x0, 0x9, 0xff, 0x90, 0x0, + 0x9, 0xff, 0x90, 0x0, 0x9, 0xff, 0x90, 0x0, + 0x9, 0xff, 0x90, 0x0, 0x9, 0xff, 0x90, 0x0, + 0x9, 0xff, 0x90, 0x0, 0x9, 0xff, 0x90, 0x0, + 0x9, 0xff, 0x90, 0x0, 0x9, 0xff, 0x90, 0x0, + 0x9, 0xff, 0x90, 0x0, 0x9, 0xff, 0x90, 0x0, + 0x9, 0xff, 0x90, 0x0, 0x9, 0xff, 0x90, 0x0, + + /* U+03B0 "ΰ" */ + 0x0, 0x0, 0x0, 0x4, 0xff, 0xd0, 0x0, 0x0, + 0x2, 0x55, 0x20, 0xb, 0xff, 0x34, 0x55, 0x10, + 0x8, 0xff, 0x80, 0x2f, 0xf7, 0xc, 0xff, 0x40, + 0x8, 0xff, 0x80, 0xaf, 0xc0, 0xc, 0xff, 0x40, + 0x8, 0xff, 0x81, 0xff, 0x20, 0xc, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf4, + 0x8f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf3, + 0x6f, 0xfe, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf0, + 0x2f, 0xff, 0x60, 0x0, 0x0, 0xa, 0xff, 0xc0, + 0xb, 0xff, 0xf5, 0x0, 0x0, 0x9f, 0xff, 0x50, + 0x2, 0xef, 0xff, 0xda, 0xbe, 0xff, 0xfa, 0x0, + 0x0, 0x2d, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x6b, 0xef, 0xfd, 0x93, 0x0, 0x0, + + /* U+03B1 "α" */ + 0x0, 0x0, 0x28, 0xdf, 0xfd, 0x93, 0x0, 0xe, + 0xff, 0x40, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xf7, + 0x3, 0xff, 0xf0, 0x0, 0x8f, 0xff, 0xfc, 0xab, + 0xff, 0xf7, 0x7f, 0xfb, 0x0, 0x4f, 0xff, 0xd2, + 0x0, 0x0, 0xaf, 0xfd, 0xff, 0x70, 0xc, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf3, 0x2, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0x0, 0x6f, 0xff, 0x10, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xc0, 0x9, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xf9, 0x0, 0xaf, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0x60, 0xb, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf3, 0x0, 0xaf, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x50, + 0x9, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xf8, 0x0, 0x6f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xc0, 0x2, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x0, 0xc, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf2, 0x0, 0x3f, + 0xff, 0xc1, 0x0, 0x1, 0xcf, 0xed, 0xff, 0x60, + 0x0, 0x7f, 0xff, 0xfb, 0x9b, 0xff, 0xf7, 0x8f, + 0xfa, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xf8, + 0x3, 0xff, 0xe0, 0x0, 0x0, 0x28, 0xdf, 0xfd, + 0xa3, 0x0, 0xd, 0xff, 0x40, + + /* U+03B2 "β" */ + 0x0, 0x0, 0x28, 0xcf, 0xfe, 0xc7, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xe3, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xeb, 0x9c, 0xff, + 0xff, 0x20, 0x0, 0x8, 0xff, 0xf6, 0x0, 0x0, + 0x2d, 0xff, 0xc0, 0x0, 0xf, 0xff, 0x40, 0x0, + 0x0, 0x1, 0xef, 0xf3, 0x0, 0x4f, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xf7, 0x0, 0x6f, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf8, 0x0, 0x8f, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf6, 0x0, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf1, + 0x0, 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x1b, 0xff, + 0x70, 0x0, 0x8f, 0xf9, 0x0, 0x25, 0x7a, 0xff, + 0xf7, 0x0, 0x0, 0x8f, 0xf9, 0x0, 0x9f, 0xff, + 0xfa, 0x20, 0x0, 0x0, 0x8f, 0xf9, 0x0, 0x9f, + 0xff, 0xff, 0xe7, 0x0, 0x0, 0x8f, 0xf9, 0x0, + 0x0, 0x14, 0x8f, 0xff, 0xd1, 0x0, 0x8f, 0xf9, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xfd, 0x0, 0x8f, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x70, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xc0, 0x8f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf0, 0x8f, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xf0, 0x8f, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf0, 0x8f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xc0, 0x8f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0x70, 0x8f, 0xff, + 0xfb, 0x10, 0x0, 0x0, 0xbf, 0xfe, 0x0, 0x8f, + 0xfc, 0xff, 0xe8, 0x55, 0x8e, 0xff, 0xf3, 0x0, + 0x8f, 0xf9, 0x3e, 0xff, 0xff, 0xff, 0xfe, 0x40, + 0x0, 0x8f, 0xf9, 0x0, 0x7c, 0xef, 0xec, 0x71, + 0x0, 0x0, 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+03B3 "γ" */ + 0x6f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xf5, 0xf, 0xff, 0x40, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf0, 0xa, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xa0, 0x4, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0x40, 0x0, 0xef, 0xf5, 0x0, + 0x0, 0x0, 0x4f, 0xfe, 0x0, 0x0, 0x8f, 0xfb, + 0x0, 0x0, 0x0, 0xaf, 0xf8, 0x0, 0x0, 0x2f, + 0xff, 0x10, 0x0, 0x0, 0xff, 0xf2, 0x0, 0x0, + 0xc, 0xff, 0x60, 0x0, 0x6, 0xff, 0xc0, 0x0, + 0x0, 0x6, 0xff, 0xc0, 0x0, 0xb, 0xff, 0x60, + 0x0, 0x0, 0x1, 0xff, 0xf1, 0x0, 0x1f, 0xff, + 0x10, 0x0, 0x0, 0x0, 0xbf, 0xf7, 0x0, 0x7f, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfd, 0x0, + 0xdf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0x22, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0x88, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xde, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0x90, 0x0, + 0x0, 0x0, + + /* U+03B4 "δ" */ + 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x20, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x9f, 0xff, 0xc8, 0x88, 0x88, + 0x88, 0x88, 0x10, 0x0, 0x7, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xdf, 0xfb, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xe5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x18, 0xdf, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x10, + 0x0, 0x0, 0x7f, 0xff, 0xe9, 0x66, 0x9e, 0xff, + 0xe2, 0x0, 0x4, 0xff, 0xfc, 0x10, 0x0, 0x1, + 0xbf, 0xfd, 0x10, 0xc, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xa0, 0x2f, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xf1, 0x6f, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xf6, 0x9f, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf9, 0xaf, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfb, + 0xbf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xfc, 0xaf, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xfb, 0x8f, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xfa, 0x5f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xf6, 0xf, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xf2, 0x9, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xb0, 0x1, 0xef, + 0xfe, 0x50, 0x0, 0x3, 0xdf, 0xff, 0x20, 0x0, + 0x4f, 0xff, 0xfd, 0xaa, 0xdf, 0xff, 0xf5, 0x0, + 0x0, 0x3, 0xdf, 0xff, 0xff, 0xff, 0xfd, 0x30, + 0x0, 0x0, 0x0, 0x6, 0xbe, 0xff, 0xda, 0x50, + 0x0, 0x0, + + /* U+03B5 "ε" */ + 0x0, 0x1, 0x7c, 0xef, 0xec, 0x71, 0x0, 0x0, + 0x2, 0xef, 0xff, 0xff, 0xff, 0xe6, 0x0, 0x0, + 0xdf, 0xff, 0xdc, 0xef, 0xff, 0xf4, 0x0, 0x6f, + 0xfe, 0x30, 0x0, 0x4c, 0xf5, 0x0, 0xa, 0xff, + 0x70, 0x0, 0x0, 0x1, 0x0, 0x0, 0xbf, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xb4, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x4e, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x1, 0xaf, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x2, 0xef, 0xff, 0xda, 0xa3, + 0x0, 0x0, 0x0, 0xcf, 0xfe, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0x30, 0x0, 0x0, 0x6, 0x50, + 0x0, 0xef, 0xfd, 0x20, 0x0, 0x19, 0xff, 0x80, + 0x6, 0xff, 0xff, 0xba, 0xbf, 0xff, 0xfa, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x3, 0x9d, 0xff, 0xeb, 0x71, 0x0, 0x0, + + /* U+03B6 "ζ" */ + 0x0, 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, + 0x0, 0xef, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, + 0x7, 0x88, 0x88, 0x88, 0xef, 0xfd, 0x20, 0x0, + 0x0, 0x0, 0x1, 0xbf, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xef, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xef, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xef, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfd, + 0x86, 0x42, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xff, 0xff, 0xb2, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x4b, 0xef, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xaf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xe3, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xec, 0x70, 0x0, 0x0, + + /* U+03B7 "η" */ + 0x9f, 0xf4, 0x1, 0x7c, 0xef, 0xda, 0x40, 0x0, + 0x9f, 0xf4, 0x4e, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x9f, 0xf8, 0xff, 0xfd, 0xcd, 0xff, 0xff, 0xa0, + 0x9f, 0xff, 0xfb, 0x20, 0x0, 0x2d, 0xff, 0xf2, + 0x9f, 0xff, 0xa0, 0x0, 0x0, 0x2, 0xff, 0xf6, + 0x9f, 0xff, 0x20, 0x0, 0x0, 0x0, 0xcf, 0xf8, + 0x9f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf9, + 0x9f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x9f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf9, + + /* U+03B8 "θ" */ + 0x0, 0x0, 0x3, 0x9d, 0xff, 0xd9, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfd, 0xaa, 0xef, + 0xff, 0xa0, 0x0, 0x0, 0x6f, 0xff, 0x60, 0x0, + 0x6, 0xff, 0xf6, 0x0, 0x0, 0xef, 0xf7, 0x0, + 0x0, 0x0, 0x6f, 0xfe, 0x0, 0x5, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0x50, 0x9, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x8, 0xff, 0xa0, 0xd, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x4, 0xff, 0xe0, + 0xf, 0xff, 0x20, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xf1, 0x2f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf3, 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xf4, 0x5f, 0xff, 0x88, 0x88, 0x88, + 0x88, 0x88, 0xef, 0xf5, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf6, 0x5f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x5f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf5, 0x4f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf4, + 0x2f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf3, 0xf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf1, 0xd, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xe0, 0x9, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xa0, 0x5, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0xe, 0xff, 0x50, 0x0, 0xef, 0xf9, + 0x0, 0x0, 0x0, 0x8f, 0xfe, 0x0, 0x0, 0x6f, + 0xff, 0x70, 0x0, 0x7, 0xff, 0xf6, 0x0, 0x0, + 0xa, 0xff, 0xfe, 0xaa, 0xdf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x3, 0x9d, 0xff, 0xd9, 0x30, + 0x0, 0x0, + + /* U+03B9 "ι" */ + 0x9f, 0xf9, 0x9f, 0xf9, 0x9f, 0xf9, 0x9f, 0xf9, + 0x9f, 0xf9, 0x9f, 0xf9, 0x9f, 0xf9, 0x9f, 0xf9, + 0x9f, 0xf9, 0x9f, 0xf9, 0x9f, 0xf9, 0x9f, 0xf9, + 0x9f, 0xf9, 0x9f, 0xf9, 0x9f, 0xf9, 0x9f, 0xf9, + 0x9f, 0xf9, 0x9f, 0xf9, 0x9f, 0xf9, + + /* U+03BA "κ" */ + 0xaf, 0xf8, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xb0, + 0xaf, 0xf8, 0x0, 0x0, 0x7, 0xff, 0xfa, 0x0, + 0xaf, 0xf8, 0x0, 0x0, 0x7f, 0xff, 0x90, 0x0, + 0xaf, 0xf8, 0x0, 0x7, 0xff, 0xf8, 0x0, 0x0, + 0xaf, 0xf8, 0x0, 0x7f, 0xff, 0x80, 0x0, 0x0, + 0xaf, 0xf8, 0x8, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0xaf, 0xf8, 0x8f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0xaf, 0xfe, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x5e, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0xaf, 0xf8, 0x3, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0xaf, 0xf8, 0x0, 0x5f, 0xff, 0xa0, 0x0, 0x0, + 0xaf, 0xf8, 0x0, 0x8, 0xff, 0xf7, 0x0, 0x0, + 0xaf, 0xf8, 0x0, 0x0, 0xbf, 0xff, 0x50, 0x0, + 0xaf, 0xf8, 0x0, 0x0, 0xd, 0xff, 0xf2, 0x0, + 0xaf, 0xf8, 0x0, 0x0, 0x2, 0xff, 0xfd, 0x10, + 0xaf, 0xf8, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xb0, + 0xaf, 0xf8, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf9, + + /* U+03BB "λ" */ + 0x0, 0x0, 0x3f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xdd, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0x77, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x12, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xfb, 0x0, 0xbf, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf5, 0x0, 0x5f, 0xff, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xe0, 0x0, 0xf, 0xff, + 0x60, 0x0, 0x0, 0xc, 0xff, 0x90, 0x0, 0x9, + 0xff, 0xc0, 0x0, 0x0, 0x2f, 0xff, 0x30, 0x0, + 0x3, 0xff, 0xf2, 0x0, 0x0, 0x8f, 0xfd, 0x0, + 0x0, 0x0, 0xdf, 0xf8, 0x0, 0x0, 0xef, 0xf7, + 0x0, 0x0, 0x0, 0x7f, 0xfd, 0x0, 0x4, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x30, 0xa, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0xb, 0xff, 0x90, + 0xf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xf0, 0x6f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf5, + + /* U+03BC "μ" */ + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf8, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf8, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf8, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf8, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf8, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf8, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf8, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf8, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf8, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf8, + 0x8f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf8, + 0x8f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf8, + 0x8f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf8, + 0x8f, 0xff, 0x20, 0x0, 0x0, 0x2, 0xff, 0xf8, + 0x8f, 0xff, 0xa0, 0x0, 0x0, 0xb, 0xff, 0xf8, + 0x8f, 0xff, 0xfa, 0x10, 0x2, 0xbf, 0xff, 0xf8, + 0x8f, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xdf, 0xf8, + 0x8f, 0xf9, 0xbf, 0xff, 0xff, 0xfc, 0x5f, 0xf8, + 0x8f, 0xf9, 0x6, 0xcf, 0xfc, 0x70, 0x4f, 0xf8, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03BD "ν" */ + 0x5f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xf6, 0xf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf0, 0x9, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xa0, 0x3, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0x40, 0x0, 0xdf, 0xf6, 0x0, + 0x0, 0x0, 0x4f, 0xfe, 0x0, 0x0, 0x7f, 0xfb, + 0x0, 0x0, 0x0, 0xaf, 0xf8, 0x0, 0x0, 0x1f, + 0xff, 0x10, 0x0, 0x0, 0xff, 0xf2, 0x0, 0x0, + 0xb, 0xff, 0x70, 0x0, 0x5, 0xff, 0xc0, 0x0, + 0x0, 0x5, 0xff, 0xc0, 0x0, 0xb, 0xff, 0x60, + 0x0, 0x0, 0x0, 0xff, 0xf2, 0x0, 0x1f, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x9f, 0xf8, 0x0, 0x7f, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfd, 0x0, + 0xcf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0x22, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0x77, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xcc, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xb0, + 0x0, 0x0, 0x0, + + /* U+03BE "ξ" */ + 0x0, 0x0, 0x6, 0xad, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x4e, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x5f, 0xff, 0xfd, 0xaa, 0x99, 0x50, 0x0, 0xe, + 0xff, 0xa1, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfc, + 0xa9, 0x99, 0x30, 0x0, 0x0, 0x3c, 0xff, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x1b, 0xff, 0xfa, 0x52, + 0x10, 0x0, 0x0, 0x1d, 0xff, 0xc2, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xd8, 0x52, 0x0, 0x0, 0x0, 0x4, 0xef, 0xff, + 0xff, 0xff, 0xb3, 0x0, 0x0, 0x1, 0x9f, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x4, 0x79, + 0xdf, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x1a, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xec, 0x81, 0x0, 0x0, + + /* U+03BF "ο" */ + 0x0, 0x0, 0x5, 0xad, 0xff, 0xda, 0x60, 0x0, + 0x0, 0x0, 0x3, 0xdf, 0xff, 0xff, 0xff, 0xfd, + 0x30, 0x0, 0x0, 0x5f, 0xff, 0xfd, 0xaa, 0xdf, + 0xff, 0xf5, 0x0, 0x3, 0xff, 0xfd, 0x30, 0x0, + 0x3, 0xdf, 0xff, 0x20, 0xb, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xb0, 0x2f, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf2, 0x6f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf6, 0x9f, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf9, + 0xaf, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xfb, 0xbf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xfb, 0xaf, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xfa, 0x9f, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xf9, 0x6f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xf6, 0x2f, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf2, 0xb, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xb0, 0x3, + 0xff, 0xfd, 0x30, 0x0, 0x3, 0xdf, 0xff, 0x20, + 0x0, 0x5f, 0xff, 0xfd, 0xaa, 0xcf, 0xff, 0xf5, + 0x0, 0x0, 0x3, 0xdf, 0xff, 0xff, 0xff, 0xfe, + 0x40, 0x0, 0x0, 0x0, 0x5, 0xad, 0xff, 0xea, + 0x60, 0x0, 0x0, + + /* U+03C0 "π" */ + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x13, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf1, 0x19, 0x99, 0x9a, 0xff, 0xf9, 0x99, 0x99, + 0x99, 0xbf, 0xfe, 0x99, 0x99, 0x0, 0x0, 0x0, + 0x4f, 0xfe, 0x0, 0x0, 0x0, 0x5, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x5f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xfe, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x5f, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xfe, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x5f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xfe, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x5f, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xfe, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x5f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xfe, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x5f, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xfe, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x5f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xfe, 0x0, 0x0, 0x0, 0x5, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x5f, 0xfd, 0x0, 0x0, 0x0, + + /* U+03C1 "ρ" */ + 0x0, 0x0, 0x28, 0xce, 0xfe, 0xc8, 0x10, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xfb, 0xab, 0xff, + 0xff, 0xa0, 0x0, 0x3, 0xff, 0xfb, 0x10, 0x0, + 0x8, 0xff, 0xf7, 0x0, 0xb, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x10, 0x1f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0xd, 0xff, 0x80, 0x5f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd0, 0x8f, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf0, + 0x9f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xf2, 0xaf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf3, 0xbf, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xf2, 0xbf, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf0, 0xbf, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xd0, 0xbf, 0xff, 0x20, + 0x0, 0x0, 0x0, 0xc, 0xff, 0x80, 0xbf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x20, 0xbf, + 0xff, 0xfa, 0x10, 0x0, 0x7, 0xff, 0xf8, 0x0, + 0xbf, 0xff, 0xff, 0xfb, 0x9a, 0xef, 0xff, 0xb0, + 0x0, 0xbf, 0xf8, 0xaf, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0xbf, 0xf7, 0x4, 0xad, 0xff, 0xd9, + 0x30, 0x0, 0x0, 0xbf, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+03C2 "ς" */ + 0x0, 0x0, 0x0, 0x5, 0x9d, 0xef, 0xfd, 0xb7, + 0x0, 0x0, 0x6, 0xef, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0x1, 0xbf, 0xff, 0xfc, 0xaa, 0xbd, 0xf7, + 0x0, 0xc, 0xff, 0xe7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xfd, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xfe, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xfe, 0x94, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xef, 0xff, 0xff, 0xfa, 0x40, 0x0, + 0x0, 0x0, 0x6, 0xdf, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x59, 0xef, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x7f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xe3, 0x0, + 0x0, 0x0, 0x3, 0xdf, 0xfe, 0xb6, 0x0, 0x0, + + /* U+03C3 "σ" */ + 0x0, 0x0, 0x5, 0xad, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x4d, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x6f, 0xff, + 0xfc, 0xaa, 0xdf, 0xff, 0xfc, 0x99, 0x99, 0x30, + 0x3f, 0xff, 0xd3, 0x0, 0x0, 0x3d, 0xff, 0xf2, + 0x0, 0x0, 0xc, 0xff, 0xd1, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xb0, 0x0, 0x3, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x20, 0x0, 0x7f, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf6, + 0x0, 0xa, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0x80, 0x0, 0xbf, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xfa, 0x0, 0xc, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xa0, + 0x0, 0xbf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf9, 0x0, 0xa, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0x80, 0x0, 0x7f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf5, 0x0, + 0x3, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0x10, 0x0, 0xc, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xa0, 0x0, 0x0, 0x3f, 0xff, + 0xc2, 0x0, 0x0, 0x3d, 0xff, 0xe2, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xfc, 0xaa, 0xdf, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x4e, 0xff, 0xff, 0xff, + 0xff, 0xc2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xbe, 0xff, 0xda, 0x40, 0x0, 0x0, 0x0, 0x0, + + /* U+03C4 "τ" */ + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x3f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x19, 0x99, + 0x9a, 0xff, 0xf9, 0x99, 0x93, 0x0, 0x0, 0x4, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xe0, 0x0, 0x0, + + /* U+03C5 "υ" */ + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf4, + 0x8f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf3, + 0x6f, 0xfe, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf0, + 0x2f, 0xff, 0x60, 0x0, 0x0, 0xa, 0xff, 0xc0, + 0xb, 0xff, 0xf5, 0x0, 0x0, 0x9f, 0xff, 0x50, + 0x2, 0xef, 0xff, 0xda, 0xbe, 0xff, 0xfa, 0x0, + 0x0, 0x2d, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x6b, 0xef, 0xfd, 0x93, 0x0, 0x0, + + /* U+03C6 "φ" */ + 0x0, 0x0, 0x18, 0xd9, 0x0, 0x3b, 0xef, 0xdb, + 0x50, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf6, 0x2, + 0xff, 0xff, 0xff, 0xfd, 0x20, 0x0, 0x0, 0x6f, + 0xff, 0xf2, 0x8, 0xff, 0xfc, 0xaf, 0xff, 0xe1, + 0x0, 0x3, 0xff, 0xfa, 0x10, 0xb, 0xff, 0xb0, + 0x1, 0xdf, 0xfa, 0x0, 0xc, 0xff, 0xb0, 0x0, + 0xb, 0xff, 0x70, 0x0, 0x2f, 0xff, 0x20, 0x2f, + 0xff, 0x20, 0x0, 0xc, 0xff, 0x50, 0x0, 0xa, + 0xff, 0x80, 0x7f, 0xfc, 0x0, 0x0, 0xc, 0xff, + 0x50, 0x0, 0x6, 0xff, 0xd0, 0x9f, 0xfa, 0x0, + 0x0, 0xc, 0xff, 0x50, 0x0, 0x4, 0xff, 0xf0, + 0xbf, 0xf8, 0x0, 0x0, 0xc, 0xff, 0x50, 0x0, + 0x3, 0xff, 0xf1, 0xbf, 0xf8, 0x0, 0x0, 0xc, + 0xff, 0x50, 0x0, 0x4, 0xff, 0xf0, 0x9f, 0xfa, + 0x0, 0x0, 0xc, 0xff, 0x50, 0x0, 0x6, 0xff, + 0xe0, 0x7f, 0xfe, 0x0, 0x0, 0xc, 0xff, 0x50, + 0x0, 0xa, 0xff, 0xa0, 0x2f, 0xff, 0x40, 0x0, + 0xc, 0xff, 0x50, 0x0, 0x1f, 0xff, 0x50, 0xc, + 0xff, 0xd0, 0x0, 0xc, 0xff, 0x50, 0x0, 0xaf, + 0xfe, 0x0, 0x4, 0xff, 0xfa, 0x0, 0xc, 0xff, + 0x50, 0x7, 0xff, 0xf4, 0x0, 0x0, 0x7f, 0xff, + 0xc4, 0xc, 0xff, 0x52, 0xaf, 0xff, 0x80, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xee, 0xff, 0xef, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x5e, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7c, 0xef, 0xff, 0xfb, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + + /* U+03C7 "χ" */ + 0xe, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xfe, 0x0, 0x6f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x60, 0x0, 0xdf, 0xf8, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xd0, 0x0, 0x5, 0xff, 0xf1, + 0x0, 0x0, 0x1, 0xff, 0xf5, 0x0, 0x0, 0xd, + 0xff, 0x80, 0x0, 0x0, 0x9f, 0xfc, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x10, 0x0, 0x1f, 0xff, 0x40, + 0x0, 0x0, 0x0, 0xdf, 0xf7, 0x0, 0x9, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xe0, 0x1, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0x70, 0x9f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xfe, 0x2f, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xfe, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xaf, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xb0, 0xdf, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xf3, 0x6, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfb, 0x0, + 0xd, 0xff, 0x70, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x20, 0x0, 0x5f, 0xfe, 0x10, 0x0, 0x0, 0xa, + 0xff, 0xa0, 0x0, 0x0, 0xdf, 0xf8, 0x0, 0x0, + 0x3, 0xff, 0xf2, 0x0, 0x0, 0x5, 0xff, 0xf2, + 0x0, 0x0, 0xcf, 0xfa, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xa0, 0x0, 0x5f, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x30, 0xd, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xfb, 0x6, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf4, + + /* U+03C8 "ψ" */ + 0xdf, 0xf4, 0x0, 0x0, 0xc, 0xff, 0x60, 0x0, + 0x0, 0xaf, 0xf8, 0xdf, 0xf4, 0x0, 0x0, 0xc, + 0xff, 0x60, 0x0, 0x0, 0xaf, 0xf8, 0xdf, 0xf4, + 0x0, 0x0, 0xc, 0xff, 0x60, 0x0, 0x0, 0xaf, + 0xf8, 0xdf, 0xf4, 0x0, 0x0, 0xc, 0xff, 0x60, + 0x0, 0x0, 0xaf, 0xf8, 0xdf, 0xf4, 0x0, 0x0, + 0xc, 0xff, 0x60, 0x0, 0x0, 0xaf, 0xf8, 0xdf, + 0xf4, 0x0, 0x0, 0xc, 0xff, 0x60, 0x0, 0x0, + 0xaf, 0xf8, 0xdf, 0xf4, 0x0, 0x0, 0xc, 0xff, + 0x60, 0x0, 0x0, 0xaf, 0xf8, 0xdf, 0xf4, 0x0, + 0x0, 0xc, 0xff, 0x60, 0x0, 0x0, 0xaf, 0xf8, + 0xdf, 0xf4, 0x0, 0x0, 0xc, 0xff, 0x60, 0x0, + 0x0, 0xaf, 0xf8, 0xdf, 0xf4, 0x0, 0x0, 0xc, + 0xff, 0x60, 0x0, 0x0, 0xaf, 0xf7, 0xdf, 0xf5, + 0x0, 0x0, 0xc, 0xff, 0x60, 0x0, 0x0, 0xaf, + 0xf7, 0xcf, 0xf6, 0x0, 0x0, 0xc, 0xff, 0x60, + 0x0, 0x0, 0xcf, 0xf6, 0xaf, 0xf8, 0x0, 0x0, + 0xc, 0xff, 0x60, 0x0, 0x0, 0xef, 0xf4, 0x8f, + 0xfd, 0x0, 0x0, 0xc, 0xff, 0x60, 0x0, 0x4, + 0xff, 0xf1, 0x2f, 0xff, 0x80, 0x0, 0xc, 0xff, + 0x60, 0x0, 0x1d, 0xff, 0xd0, 0x9, 0xff, 0xf9, + 0x10, 0xc, 0xff, 0x60, 0x4, 0xdf, 0xff, 0x50, + 0x0, 0xbf, 0xff, 0xfd, 0xbe, 0xff, 0xdc, 0xef, + 0xff, 0xf8, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x50, 0x0, 0x0, 0x0, + 0x17, 0xbe, 0xff, 0xff, 0xff, 0xda, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + + /* U+03C9 "ω" */ + 0x0, 0xe, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xf1, 0x0, 0x0, 0x7f, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xf8, 0x0, 0x0, 0xef, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x0, 0x4, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0x60, 0xa, 0xff, 0xa0, 0x0, + 0x0, 0x2, 0x55, 0x30, 0x0, 0x0, 0x8, 0xff, + 0xc0, 0xe, 0xff, 0x50, 0x0, 0x0, 0x8, 0xff, + 0xa0, 0x0, 0x0, 0x4, 0xff, 0xf0, 0x2f, 0xff, + 0x20, 0x0, 0x0, 0x8, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0xff, 0xf3, 0x5f, 0xff, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xdf, 0xf6, + 0x6f, 0xfd, 0x0, 0x0, 0x0, 0x8, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0xbf, 0xf7, 0x7f, 0xfc, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0xaf, 0xf8, 0x6f, 0xfc, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0xaf, 0xf8, 0x5f, + 0xfd, 0x0, 0x0, 0x0, 0x9, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0xcf, 0xf7, 0x3f, 0xff, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xc0, 0x0, 0x0, 0x0, 0xef, + 0xf4, 0xf, 0xff, 0x50, 0x0, 0x0, 0xd, 0xff, + 0xf0, 0x0, 0x0, 0x3, 0xff, 0xf1, 0xa, 0xff, + 0xc0, 0x0, 0x0, 0x4f, 0xff, 0xf6, 0x0, 0x0, + 0xb, 0xff, 0xc0, 0x3, 0xff, 0xf8, 0x0, 0x2, + 0xef, 0xb9, 0xff, 0x30, 0x0, 0x6f, 0xff, 0x50, + 0x0, 0x8f, 0xff, 0xc8, 0xaf, 0xff, 0x21, 0xef, + 0xfa, 0x8b, 0xff, 0xfa, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x3e, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x4b, 0xef, 0xe9, 0x20, + 0x0, 0x1, 0x9d, 0xfe, 0xb5, 0x0, 0x0, + + /* U+03CA "ϊ" */ + 0xff, 0xf5, 0x0, 0x6f, 0xfe, 0xff, 0xf5, 0x0, + 0x6f, 0xfe, 0xff, 0xf5, 0x0, 0x6f, 0xfe, 0x89, + 0x93, 0x0, 0x39, 0x98, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0x90, 0x0, + 0x0, 0x9, 0xff, 0x90, 0x0, 0x0, 0x9, 0xff, + 0x90, 0x0, 0x0, 0x9, 0xff, 0x90, 0x0, 0x0, + 0x9, 0xff, 0x90, 0x0, 0x0, 0x9, 0xff, 0x90, + 0x0, 0x0, 0x9, 0xff, 0x90, 0x0, 0x0, 0x9, + 0xff, 0x90, 0x0, 0x0, 0x9, 0xff, 0x90, 0x0, + 0x0, 0x9, 0xff, 0x90, 0x0, 0x0, 0x9, 0xff, + 0x90, 0x0, 0x0, 0x9, 0xff, 0x90, 0x0, 0x0, + 0x9, 0xff, 0x90, 0x0, 0x0, 0x9, 0xff, 0x90, + 0x0, 0x0, 0x9, 0xff, 0x90, 0x0, 0x0, 0x9, + 0xff, 0x90, 0x0, 0x0, 0x9, 0xff, 0x90, 0x0, + 0x0, 0x9, 0xff, 0x90, 0x0, 0x0, 0x9, 0xff, + 0x90, 0x0, + + /* U+03CB "ϋ" */ + 0x0, 0x1f, 0xff, 0x30, 0x8, 0xff, 0xc0, 0x0, + 0x0, 0x1f, 0xff, 0x30, 0x8, 0xff, 0xc0, 0x0, + 0x0, 0x1f, 0xff, 0x30, 0x8, 0xff, 0xc0, 0x0, + 0x0, 0x9, 0x99, 0x20, 0x4, 0x99, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf4, + 0x8f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf3, + 0x6f, 0xfe, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf0, + 0x2f, 0xff, 0x60, 0x0, 0x0, 0xa, 0xff, 0xc0, + 0xb, 0xff, 0xf5, 0x0, 0x0, 0x9f, 0xff, 0x50, + 0x2, 0xef, 0xff, 0xda, 0xbe, 0xff, 0xfa, 0x0, + 0x0, 0x2d, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x6b, 0xef, 0xfd, 0x93, 0x0, 0x0, + + /* U+03CC "ό" */ + 0x0, 0x0, 0x0, 0x0, 0xd, 0xee, 0xd1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xad, 0xff, 0xda, 0x60, 0x0, + 0x0, 0x0, 0x3, 0xdf, 0xff, 0xff, 0xff, 0xfd, + 0x30, 0x0, 0x0, 0x5f, 0xff, 0xfd, 0xaa, 0xdf, + 0xff, 0xf5, 0x0, 0x3, 0xff, 0xfd, 0x30, 0x0, + 0x3, 0xdf, 0xff, 0x20, 0xb, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xb0, 0x2f, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf2, 0x6f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf6, 0x9f, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf9, + 0xaf, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xfb, 0xbf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xfb, 0xaf, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xfa, 0x9f, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xf9, 0x6f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xf6, 0x2f, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf2, 0xb, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xb0, 0x3, + 0xff, 0xfd, 0x30, 0x0, 0x3, 0xdf, 0xff, 0x20, + 0x0, 0x5f, 0xff, 0xfd, 0xaa, 0xcf, 0xff, 0xf5, + 0x0, 0x0, 0x3, 0xdf, 0xff, 0xff, 0xff, 0xfe, + 0x40, 0x0, 0x0, 0x0, 0x5, 0xad, 0xff, 0xea, + 0x60, 0x0, 0x0, + + /* U+03CD "ύ" */ + 0x0, 0x0, 0x0, 0x1, 0xee, 0xec, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf4, + 0x8f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf3, + 0x6f, 0xfe, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf0, + 0x2f, 0xff, 0x60, 0x0, 0x0, 0xa, 0xff, 0xc0, + 0xb, 0xff, 0xf5, 0x0, 0x0, 0x9f, 0xff, 0x50, + 0x2, 0xef, 0xff, 0xda, 0xbe, 0xff, 0xfa, 0x0, + 0x0, 0x2d, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x6b, 0xef, 0xfd, 0x93, 0x0, 0x0, + + /* U+03CE "ώ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xee, + 0xd2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xf1, 0x0, 0x0, 0x7f, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xf8, 0x0, 0x0, 0xef, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x0, 0x4, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0x60, 0xa, 0xff, 0xa0, 0x0, + 0x0, 0x2, 0x55, 0x30, 0x0, 0x0, 0x8, 0xff, + 0xc0, 0xe, 0xff, 0x50, 0x0, 0x0, 0x8, 0xff, + 0xa0, 0x0, 0x0, 0x4, 0xff, 0xf0, 0x2f, 0xff, + 0x20, 0x0, 0x0, 0x8, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0xff, 0xf3, 0x5f, 0xff, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xdf, 0xf6, + 0x6f, 0xfd, 0x0, 0x0, 0x0, 0x8, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0xbf, 0xf7, 0x7f, 0xfc, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0xaf, 0xf8, 0x6f, 0xfc, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0xaf, 0xf8, 0x5f, + 0xfd, 0x0, 0x0, 0x0, 0x9, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0xcf, 0xf7, 0x3f, 0xff, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xc0, 0x0, 0x0, 0x0, 0xef, + 0xf4, 0xf, 0xff, 0x50, 0x0, 0x0, 0xd, 0xff, + 0xf0, 0x0, 0x0, 0x3, 0xff, 0xf1, 0xa, 0xff, + 0xc0, 0x0, 0x0, 0x4f, 0xff, 0xf6, 0x0, 0x0, + 0xb, 0xff, 0xc0, 0x3, 0xff, 0xf8, 0x0, 0x2, + 0xef, 0xb9, 0xff, 0x30, 0x0, 0x6f, 0xff, 0x50, + 0x0, 0x8f, 0xff, 0xc8, 0xaf, 0xff, 0x21, 0xef, + 0xfa, 0x8b, 0xff, 0xfa, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x3e, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x4b, 0xef, 0xe9, 0x20, + 0x0, 0x1, 0x9d, 0xfe, 0xb5, 0x0, 0x0, + + /* U+03F4 "ϴ" */ + 0x0, 0x0, 0x0, 0x2f, 0xfe, 0x10, 0x0, 0x25, + 0x53, 0x0, 0x9f, 0xf5, 0x35, 0x52, 0x6f, 0xfa, + 0x1, 0xff, 0x90, 0xaf, 0xf6, 0x6f, 0xfa, 0x8, + 0xfd, 0x0, 0xaf, 0xf6, 0x6f, 0xfa, 0xe, 0xf3, + 0x0, 0xaf, 0xf6 +}; + + +/*--------------------- + * GLYPH DESCRIPTION + *--------------------*/ + +static const lv_font_fmt_txt_glyph_dsc_t glyph_dsc[] = { + {.bitmap_index = 0, .adv_w = 0, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0} /* id = 0 reserved */, + {.bitmap_index = 0, .adv_w = 160, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 0, .adv_w = 161, .box_w = 4, .box_h = 26, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 52, .adv_w = 204, .box_w = 11, .box_h = 10, .ofs_x = 1, .ofs_y = 16}, + {.bitmap_index = 107, .adv_w = 320, .box_w = 20, .box_h = 26, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 367, .adv_w = 320, .box_w = 18, .box_h = 32, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 655, .adv_w = 512, .box_w = 28, .box_h = 27, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 1033, .adv_w = 384, .box_w = 23, .box_h = 27, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 1344, .adv_w = 109, .box_w = 5, .box_h = 10, .ofs_x = 1, .ofs_y = 16}, + {.bitmap_index = 1369, .adv_w = 192, .box_w = 9, .box_h = 33, .ofs_x = 2, .ofs_y = -7}, + {.bitmap_index = 1518, .adv_w = 192, .box_w = 9, .box_h = 33, .ofs_x = 1, .ofs_y = -7}, + {.bitmap_index = 1667, .adv_w = 224, .box_w = 12, .box_h = 11, .ofs_x = 1, .ofs_y = 15}, + {.bitmap_index = 1733, .adv_w = 336, .box_w = 18, .box_h = 17, .ofs_x = 2, .ofs_y = 4}, + {.bitmap_index = 1886, .adv_w = 161, .box_w = 5, .box_h = 10, .ofs_x = 2, .ofs_y = -6}, + {.bitmap_index = 1911, .adv_w = 192, .box_w = 10, .box_h = 4, .ofs_x = 1, .ofs_y = 8}, + {.bitmap_index = 1931, .adv_w = 161, .box_w = 4, .box_h = 4, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 1939, .adv_w = 160, .box_w = 10, .box_h = 26, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2069, .adv_w = 320, .box_w = 18, .box_h = 26, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2303, .adv_w = 320, .box_w = 11, .box_h = 26, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 2446, .adv_w = 320, .box_w = 18, .box_h = 26, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2680, .adv_w = 320, .box_w = 18, .box_h = 26, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2914, .adv_w = 320, .box_w = 19, .box_h = 26, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3161, .adv_w = 320, .box_w = 18, .box_h = 26, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3395, .adv_w = 320, .box_w = 18, .box_h = 26, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3629, .adv_w = 320, .box_w = 18, .box_h = 26, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3863, .adv_w = 320, .box_w = 18, .box_h = 26, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4097, .adv_w = 320, .box_w = 18, .box_h = 26, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4331, .adv_w = 161, .box_w = 4, .box_h = 19, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 4369, .adv_w = 161, .box_w = 5, .box_h = 25, .ofs_x = 2, .ofs_y = -6}, + {.bitmap_index = 4432, .adv_w = 336, .box_w = 19, .box_h = 19, .ofs_x = 1, .ofs_y = 3}, + {.bitmap_index = 4613, .adv_w = 336, .box_w = 18, .box_h = 11, .ofs_x = 2, .ofs_y = 7}, + {.bitmap_index = 4712, .adv_w = 336, .box_w = 19, .box_h = 19, .ofs_x = 1, .ofs_y = 3}, + {.bitmap_index = 4893, .adv_w = 320, .box_w = 18, .box_h = 26, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 5127, .adv_w = 585, .box_w = 34, .box_h = 33, .ofs_x = 2, .ofs_y = -7}, + {.bitmap_index = 5688, .adv_w = 384, .box_w = 26, .box_h = 26, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 6026, .adv_w = 384, .box_w = 21, .box_h = 26, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 6299, .adv_w = 416, .box_w = 24, .box_h = 26, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 6611, .adv_w = 416, .box_w = 23, .box_h = 26, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 6910, .adv_w = 384, .box_w = 21, .box_h = 26, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 7183, .adv_w = 353, .box_w = 19, .box_h = 26, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 7430, .adv_w = 448, .box_w = 25, .box_h = 26, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 7755, .adv_w = 416, .box_w = 22, .box_h = 26, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 8041, .adv_w = 161, .box_w = 4, .box_h = 26, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 8093, .adv_w = 288, .box_w = 16, .box_h = 26, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 8301, .adv_w = 384, .box_w = 22, .box_h = 26, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 8587, .adv_w = 320, .box_w = 17, .box_h = 26, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 8808, .adv_w = 480, .box_w = 26, .box_h = 26, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 9146, .adv_w = 416, .box_w = 22, .box_h = 26, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 9432, .adv_w = 448, .box_w = 26, .box_h = 26, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 9770, .adv_w = 384, .box_w = 21, .box_h = 26, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 10043, .adv_w = 448, .box_w = 26, .box_h = 28, .ofs_x = 1, .ofs_y = -2}, + {.bitmap_index = 10407, .adv_w = 416, .box_w = 24, .box_h = 26, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 10719, .adv_w = 384, .box_w = 22, .box_h = 26, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 11005, .adv_w = 353, .box_w = 22, .box_h = 26, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 11291, .adv_w = 416, .box_w = 22, .box_h = 26, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 11577, .adv_w = 384, .box_w = 24, .box_h = 26, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 11889, .adv_w = 544, .box_w = 34, .box_h = 26, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 12331, .adv_w = 384, .box_w = 24, .box_h = 26, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 12643, .adv_w = 384, .box_w = 24, .box_h = 26, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 12955, .adv_w = 353, .box_w = 22, .box_h = 26, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 13241, .adv_w = 161, .box_w = 8, .box_h = 33, .ofs_x = 2, .ofs_y = -7}, + {.bitmap_index = 13373, .adv_w = 160, .box_w = 10, .box_h = 26, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 13503, .adv_w = 161, .box_w = 8, .box_h = 33, .ofs_x = 0, .ofs_y = -7}, + {.bitmap_index = 13635, .adv_w = 270, .box_w = 16, .box_h = 14, .ofs_x = 0, .ofs_y = 12}, + {.bitmap_index = 13747, .adv_w = 320, .box_w = 22, .box_h = 3, .ofs_x = -1, .ofs_y = -7}, + {.bitmap_index = 13780, .adv_w = 192, .box_w = 8, .box_h = 5, .ofs_x = 1, .ofs_y = 21}, + {.bitmap_index = 13800, .adv_w = 320, .box_w = 18, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 13971, .adv_w = 320, .box_w = 17, .box_h = 26, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 14192, .adv_w = 288, .box_w = 17, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 14354, .adv_w = 320, .box_w = 17, .box_h = 26, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 14575, .adv_w = 320, .box_w = 18, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 14746, .adv_w = 161, .box_w = 12, .box_h = 26, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 14902, .adv_w = 320, .box_w = 17, .box_h = 26, .ofs_x = 1, .ofs_y = -7}, + {.bitmap_index = 15123, .adv_w = 320, .box_w = 16, .box_h = 26, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 15331, .adv_w = 128, .box_w = 4, .box_h = 26, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 15383, .adv_w = 128, .box_w = 8, .box_h = 33, .ofs_x = -2, .ofs_y = -7}, + {.bitmap_index = 15515, .adv_w = 288, .box_w = 16, .box_h = 26, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 15723, .adv_w = 128, .box_w = 4, .box_h = 26, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 15775, .adv_w = 480, .box_w = 26, .box_h = 19, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 16022, .adv_w = 320, .box_w = 16, .box_h = 19, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 16174, .adv_w = 320, .box_w = 18, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 16345, .adv_w = 320, .box_w = 17, .box_h = 26, .ofs_x = 2, .ofs_y = -7}, + {.bitmap_index = 16566, .adv_w = 320, .box_w = 17, .box_h = 26, .ofs_x = 1, .ofs_y = -7}, + {.bitmap_index = 16787, .adv_w = 192, .box_w = 11, .box_h = 19, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 16892, .adv_w = 288, .box_w = 16, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 17044, .adv_w = 161, .box_w = 10, .box_h = 26, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 17174, .adv_w = 320, .box_w = 16, .box_h = 19, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 17326, .adv_w = 288, .box_w = 18, .box_h = 19, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 17497, .adv_w = 416, .box_w = 26, .box_h = 19, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 17744, .adv_w = 288, .box_w = 18, .box_h = 19, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 17915, .adv_w = 288, .box_w = 18, .box_h = 26, .ofs_x = 0, .ofs_y = -7}, + {.bitmap_index = 18149, .adv_w = 288, .box_w = 18, .box_h = 19, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 18320, .adv_w = 192, .box_w = 11, .box_h = 33, .ofs_x = 1, .ofs_y = -7}, + {.bitmap_index = 18502, .adv_w = 150, .box_w = 4, .box_h = 33, .ofs_x = 3, .ofs_y = -7}, + {.bitmap_index = 18568, .adv_w = 192, .box_w = 11, .box_h = 33, .ofs_x = 0, .ofs_y = -7}, + {.bitmap_index = 18750, .adv_w = 336, .box_w = 19, .box_h = 7, .ofs_x = 1, .ofs_y = 9}, + {.bitmap_index = 18817, .adv_w = 160, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 18817, .adv_w = 320, .box_w = 20, .box_h = 27, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 19087, .adv_w = 320, .box_w = 18, .box_h = 19, .ofs_x = 1, .ofs_y = 3}, + {.bitmap_index = 19258, .adv_w = 320, .box_w = 20, .box_h = 26, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 19518, .adv_w = 150, .box_w = 4, .box_h = 33, .ofs_x = 3, .ofs_y = -7}, + {.bitmap_index = 19584, .adv_w = 320, .box_w = 18, .box_h = 33, .ofs_x = 1, .ofs_y = -7}, + {.bitmap_index = 19881, .adv_w = 192, .box_w = 10, .box_h = 4, .ofs_x = 1, .ofs_y = 22}, + {.bitmap_index = 19901, .adv_w = 424, .box_w = 27, .box_h = 27, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 20266, .adv_w = 216, .box_w = 13, .box_h = 13, .ofs_x = 0, .ofs_y = 13}, + {.bitmap_index = 20351, .adv_w = 320, .box_w = 16, .box_h = 16, .ofs_x = 2, .ofs_y = 1}, + {.bitmap_index = 20479, .adv_w = 336, .box_w = 18, .box_h = 11, .ofs_x = 2, .ofs_y = 7}, + {.bitmap_index = 20578, .adv_w = 192, .box_w = 10, .box_h = 4, .ofs_x = 1, .ofs_y = 8}, + {.bitmap_index = 20598, .adv_w = 424, .box_w = 27, .box_h = 27, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 20963, .adv_w = 230, .box_w = 11, .box_h = 10, .ofs_x = 2, .ofs_y = 16}, + {.bitmap_index = 21018, .adv_w = 336, .box_w = 18, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 21216, .adv_w = 192, .box_w = 12, .box_h = 13, .ofs_x = 0, .ofs_y = 13}, + {.bitmap_index = 21294, .adv_w = 192, .box_w = 12, .box_h = 13, .ofs_x = 0, .ofs_y = 13}, + {.bitmap_index = 21372, .adv_w = 320, .box_w = 16, .box_h = 26, .ofs_x = 2, .ofs_y = -7}, + {.bitmap_index = 21580, .adv_w = 309, .box_w = 21, .box_h = 33, .ofs_x = -1, .ofs_y = -7}, + {.bitmap_index = 21927, .adv_w = 161, .box_w = 4, .box_h = 4, .ofs_x = 3, .ofs_y = 11}, + {.bitmap_index = 21935, .adv_w = 320, .box_w = 16, .box_h = 16, .ofs_x = 2, .ofs_y = 1}, + {.bitmap_index = 22063, .adv_w = 480, .box_w = 29, .box_h = 28, .ofs_x = 1, .ofs_y = -2}, + {.bitmap_index = 22469, .adv_w = 192, .box_w = 8, .box_h = 5, .ofs_x = 3, .ofs_y = 21}, + {.bitmap_index = 22489, .adv_w = 384, .box_w = 26, .box_h = 26, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 22827, .adv_w = 452, .box_w = 29, .box_h = 26, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 23204, .adv_w = 483, .box_w = 29, .box_h = 26, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 23581, .adv_w = 221, .box_w = 12, .box_h = 26, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 23737, .adv_w = 446, .box_w = 29, .box_h = 26, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 24114, .adv_w = 493, .box_w = 33, .box_h = 26, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 24543, .adv_w = 433, .box_w = 28, .box_h = 26, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 24907, .adv_w = 128, .box_w = 14, .box_h = 27, .ofs_x = -3, .ofs_y = 0}, + {.bitmap_index = 25096, .adv_w = 384, .box_w = 26, .box_h = 26, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 25434, .adv_w = 384, .box_w = 21, .box_h = 26, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 25707, .adv_w = 317, .box_w = 17, .box_h = 26, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 25928, .adv_w = 385, .box_w = 26, .box_h = 26, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 26266, .adv_w = 384, .box_w = 21, .box_h = 26, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 26539, .adv_w = 353, .box_w = 22, .box_h = 26, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 26825, .adv_w = 416, .box_w = 22, .box_h = 26, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 27111, .adv_w = 448, .box_w = 26, .box_h = 26, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 27449, .adv_w = 161, .box_w = 4, .box_h = 26, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 27501, .adv_w = 384, .box_w = 22, .box_h = 26, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 27787, .adv_w = 385, .box_w = 24, .box_h = 26, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 28099, .adv_w = 480, .box_w = 26, .box_h = 26, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 28437, .adv_w = 416, .box_w = 22, .box_h = 26, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 28723, .adv_w = 374, .box_w = 21, .box_h = 26, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 28996, .adv_w = 448, .box_w = 26, .box_h = 26, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 29334, .adv_w = 416, .box_w = 22, .box_h = 26, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 29620, .adv_w = 384, .box_w = 21, .box_h = 26, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 29893, .adv_w = 356, .box_w = 19, .box_h = 26, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 30140, .adv_w = 353, .box_w = 22, .box_h = 26, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 30426, .adv_w = 384, .box_w = 24, .box_h = 26, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 30738, .adv_w = 460, .box_w = 27, .box_h = 28, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 31116, .adv_w = 384, .box_w = 24, .box_h = 26, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 31428, .adv_w = 481, .box_w = 26, .box_h = 26, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 31766, .adv_w = 431, .box_w = 25, .box_h = 26, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 32091, .adv_w = 161, .box_w = 11, .box_h = 31, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 32262, .adv_w = 384, .box_w = 24, .box_h = 31, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 32634, .adv_w = 333, .box_w = 19, .box_h = 27, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 32891, .adv_w = 257, .box_w = 15, .box_h = 27, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 33094, .adv_w = 320, .box_w = 16, .box_h = 34, .ofs_x = 2, .ofs_y = -7}, + {.bitmap_index = 33366, .adv_w = 128, .box_w = 8, .box_h = 26, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 33470, .adv_w = 315, .box_w = 16, .box_h = 27, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 33686, .adv_w = 333, .box_w = 19, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 33867, .adv_w = 331, .box_w = 18, .box_h = 33, .ofs_x = 2, .ofs_y = -7}, + {.bitmap_index = 34164, .adv_w = 288, .box_w = 18, .box_h = 26, .ofs_x = 0, .ofs_y = -7}, + {.bitmap_index = 34398, .adv_w = 321, .box_w = 18, .box_h = 26, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 34632, .adv_w = 257, .box_w = 15, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 34775, .adv_w = 254, .box_w = 15, .box_h = 33, .ofs_x = 1, .ofs_y = -7}, + {.bitmap_index = 35023, .adv_w = 320, .box_w = 16, .box_h = 26, .ofs_x = 2, .ofs_y = -7}, + {.bitmap_index = 35231, .adv_w = 320, .box_w = 18, .box_h = 26, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 35465, .adv_w = 128, .box_w = 4, .box_h = 19, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 35503, .adv_w = 287, .box_w = 16, .box_h = 19, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 35655, .adv_w = 288, .box_w = 18, .box_h = 26, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 35889, .adv_w = 320, .box_w = 16, .box_h = 26, .ofs_x = 2, .ofs_y = -7}, + {.bitmap_index = 36097, .adv_w = 288, .box_w = 18, .box_h = 19, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 36268, .adv_w = 258, .box_w = 15, .box_h = 33, .ofs_x = 1, .ofs_y = -7}, + {.bitmap_index = 36516, .adv_w = 320, .box_w = 18, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 36687, .adv_w = 397, .box_w = 25, .box_h = 19, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 36925, .adv_w = 328, .box_w = 18, .box_h = 26, .ofs_x = 2, .ofs_y = -7}, + {.bitmap_index = 37159, .adv_w = 278, .box_w = 16, .box_h = 26, .ofs_x = 1, .ofs_y = -7}, + {.bitmap_index = 37367, .adv_w = 356, .box_w = 21, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 37567, .adv_w = 228, .box_w = 14, .box_h = 19, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 37700, .adv_w = 315, .box_w = 16, .box_h = 19, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 37852, .adv_w = 374, .box_w = 22, .box_h = 26, .ofs_x = 1, .ofs_y = -7}, + {.bitmap_index = 38138, .adv_w = 302, .box_w = 19, .box_h = 26, .ofs_x = 0, .ofs_y = -7}, + {.bitmap_index = 38385, .adv_w = 411, .box_w = 22, .box_h = 26, .ofs_x = 2, .ofs_y = -7}, + {.bitmap_index = 38671, .adv_w = 450, .box_w = 26, .box_h = 19, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 38918, .adv_w = 128, .box_w = 10, .box_h = 26, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 39048, .adv_w = 315, .box_w = 16, .box_h = 26, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 39256, .adv_w = 320, .box_w = 18, .box_h = 27, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 39499, .adv_w = 315, .box_w = 16, .box_h = 27, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 39715, .adv_w = 450, .box_w = 26, .box_h = 27, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 40066, .adv_w = 192, .box_w = 14, .box_h = 5, .ofs_x = -1, .ofs_y = 22} +}; + +/*--------------------- + * CHARACTER MAPPING + *--------------------*/ + +static const uint8_t glyph_id_ofs_list_1[] = { + 0, 0, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 0, + 13, 14, 15, 16, 0, 17, 18, 19, + 0, 0, 0, 20, 0, 21 +}; + +static const uint8_t glyph_id_ofs_list_2[] = { + 0, 0, 1, 0, 2, 3, 4, 0, + 5 +}; + +/*Collect the unicode lists and glyph_id offsets*/ +static const lv_font_fmt_txt_cmap_t cmaps[] = +{ + { + .range_start = 32, .range_length = 95, .glyph_id_start = 1, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 160, .range_length = 30, .glyph_id_start = 96, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_1, .list_length = 30, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 900, .range_length = 9, .glyph_id_start = 118, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_2, .list_length = 9, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 910, .range_length = 20, .glyph_id_start = 124, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 931, .range_length = 44, .glyph_id_start = 144, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 1012, .range_length = 1, .glyph_id_start = 188, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + } +}; + + + +/*-------------------- + * ALL CUSTOM DATA + *--------------------*/ + +#if LVGL_VERSION_MAJOR == 8 +/*Store all the custom data of the font*/ +static lv_font_fmt_txt_glyph_cache_t cache; +#endif + +#if LVGL_VERSION_MAJOR >= 8 +static const lv_font_fmt_txt_dsc_t font_dsc = { +#else +static lv_font_fmt_txt_dsc_t font_dsc = { +#endif + .glyph_bitmap = glyph_bitmap, + .glyph_dsc = glyph_dsc, + .cmaps = cmaps, + .kern_dsc = NULL, + .kern_scale = 0, + .cmap_num = 6, + .bpp = 4, + .kern_classes = 0, + .bitmap_format = 0, +#if LVGL_VERSION_MAJOR == 8 + .cache = &cache +#endif + +}; + +extern const lv_font_t lv_font_montserrat_36; + + +/*----------------- + * PUBLIC FONT + *----------------*/ + +/*Initialize a public general font descriptor*/ +#if LVGL_VERSION_MAJOR >= 8 +const lv_font_t lv_font_arial_36 = { +#else +lv_font_t lv_font_arial_36 = { +#endif + .get_glyph_dsc = lv_font_get_glyph_dsc_fmt_txt, /*Function pointer to get glyph's data*/ + .get_glyph_bitmap = lv_font_get_bitmap_fmt_txt, /*Function pointer to get glyph's bitmap*/ + .line_height = 38, /*The maximum line height required by the font*/ + .base_line = 7, /*Baseline measured from the bottom of the line*/ +#if !(LVGL_VERSION_MAJOR == 6 && LVGL_VERSION_MINOR == 0) + .subpx = LV_FONT_SUBPX_NONE, +#endif +#if LV_VERSION_CHECK(7, 4, 0) || LVGL_VERSION_MAJOR >= 8 + .underline_position = -4, + .underline_thickness = 3, +#endif + //.static_bitmap = 0, + .dsc = &font_dsc, /*The custom font data. Will be accessed by `get_glyph_bitmap/dsc` */ +#if LV_VERSION_CHECK(8, 2, 0) || LVGL_VERSION_MAJOR >= 9 + .fallback = &lv_font_montserrat_36, +#endif + .user_data = NULL, +}; + + + +#endif /*#if LV_FONT_ARIAL_36*/ diff --git a/src/fonts/lv_font_arial_38.c b/src/fonts/lv_font_arial_38.c new file mode 100644 index 0000000000..a1fc178821 --- /dev/null +++ b/src/fonts/lv_font_arial_38.c @@ -0,0 +1,6302 @@ +/******************************************************************************* + * Size: 38 px + * Bpp: 4 + * Opts: --bpp 4 --size 38 --no-compress --stride 1 --align 1 --font Arial Greek Regular.ttf --range 32-127,160-255,880-1023 --format lvgl -o lv_font_arial_38.c + ******************************************************************************/ + +#ifdef __has_include + #if __has_include("lvgl.h") + #ifndef LV_LVGL_H_INCLUDE_SIMPLE + #define LV_LVGL_H_INCLUDE_SIMPLE + #endif + #endif +#endif + +#ifdef LV_LVGL_H_INCLUDE_SIMPLE + #include "lvgl.h" +#else + #include "lvgl/lvgl.h" +#endif + + + +#ifndef LV_FONT_ARIAL_38 +#define LV_FONT_ARIAL_38 1 +#endif + +#if LV_FONT_ARIAL_38 + +/*----------------- + * BITMAPS + *----------------*/ + +/*Store the image of the glyphs*/ +static LV_ATTRIBUTE_LARGE_CONST const uint8_t glyph_bitmap[] = { + /* U+0020 " " */ + + /* U+0021 "!" */ + 0xcf, 0xff, 0x5c, 0xff, 0xf5, 0xcf, 0xff, 0x5c, + 0xff, 0xf5, 0xcf, 0xff, 0x5c, 0xff, 0xf5, 0xcf, + 0xff, 0x4b, 0xff, 0xf3, 0x9f, 0xff, 0x28, 0xff, + 0xf1, 0x7f, 0xff, 0x6, 0xff, 0xf0, 0x5f, 0xfe, + 0x4, 0xff, 0xd0, 0x2f, 0xfc, 0x1, 0xff, 0xb0, + 0xf, 0xfa, 0x0, 0xff, 0x90, 0xe, 0xf8, 0x0, + 0xdf, 0x70, 0x3, 0x41, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xcc, 0xc2, 0xaf, 0xff, 0x3a, 0xff, + 0xf3, 0xaf, 0xff, 0x30, + + /* U+0022 "\"" */ + 0x3f, 0xff, 0x90, 0x1f, 0xff, 0xb3, 0xff, 0xf9, + 0x1, 0xff, 0xfb, 0x3f, 0xff, 0x90, 0x1f, 0xff, + 0xb3, 0xff, 0xf9, 0x1, 0xff, 0xfb, 0x3f, 0xff, + 0x80, 0xf, 0xff, 0xb0, 0xff, 0xf6, 0x0, 0xef, + 0xf8, 0xd, 0xff, 0x30, 0xb, 0xff, 0x50, 0xaf, + 0xf1, 0x0, 0x8f, 0xf3, 0x8, 0xfe, 0x0, 0x5, + 0xff, 0x0, 0x38, 0x60, 0x0, 0x18, 0x70, + + /* U+0023 "#" */ + 0x0, 0x0, 0x0, 0x6, 0xff, 0x50, 0x0, 0x0, + 0xcf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf2, + 0x0, 0x0, 0xf, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xfe, 0x0, 0x0, 0x3, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xa0, 0x0, 0x0, 0x7f, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xf7, 0x0, + 0x0, 0xb, 0xff, 0x10, 0x0, 0x0, 0x0, 0x9, + 0xff, 0x30, 0x0, 0x0, 0xef, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xf0, 0x0, 0x0, 0x2f, 0xfa, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb6, 0xbb, + 0xbb, 0xdf, 0xfc, 0xbb, 0xbb, 0xbf, 0xff, 0xbb, + 0xb8, 0x0, 0x0, 0xa, 0xff, 0x20, 0x0, 0x0, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xe0, + 0x0, 0x0, 0x3f, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xfb, 0x0, 0x0, 0x6, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x4, 0xff, 0x80, 0x0, 0x0, 0xaf, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf4, 0x0, + 0x0, 0xd, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0x10, 0x0, 0x1, 0xff, 0xb0, 0x0, 0x0, + 0x6c, 0xcc, 0xff, 0xfc, 0xcc, 0xcc, 0xcf, 0xfe, + 0xcc, 0xcc, 0x88, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0x8f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x8f, 0xf4, 0x0, 0x0, 0xe, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0x10, 0x0, 0x1, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xe0, + 0x0, 0x0, 0x4f, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xfa, 0x0, 0x0, 0x7, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x5, 0xff, 0x70, 0x0, 0x0, 0xbf, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf4, 0x0, + 0x0, 0xe, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0x10, 0x0, 0x1, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xd0, 0x0, 0x0, 0x4f, 0xf7, + 0x0, 0x0, 0x0, 0x0, + + /* U+0024 "$" */ + 0x0, 0x0, 0x0, 0x0, 0x7f, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x4a, 0xfb, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4b, 0xff, 0xff, + 0xff, 0xfb, 0x30, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x7f, + 0xff, 0xf9, 0xbf, 0xbb, 0xff, 0xff, 0x50, 0x0, + 0x2f, 0xff, 0xc1, 0x7, 0xf8, 0x5, 0xff, 0xfe, + 0x0, 0x8, 0xff, 0xf1, 0x0, 0x7f, 0x80, 0x7, + 0xff, 0xf5, 0x0, 0xdf, 0xf9, 0x0, 0x7, 0xf8, + 0x0, 0xf, 0xff, 0x90, 0xf, 0xff, 0x60, 0x0, + 0x7f, 0x80, 0x0, 0x99, 0x73, 0x0, 0xff, 0xf6, + 0x0, 0x7, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xa0, 0x0, 0x7f, 0x80, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0x30, 0x7, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x50, 0x7f, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xdc, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xfc, 0x82, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xbf, 0xff, 0xff, 0xff, 0xfa, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x27, 0xdf, 0xff, 0xff, 0xfe, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x7, 0xfa, 0x8e, + 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0x80, 0x9, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xf8, 0x0, 0xb, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0x80, 0x0, 0x4f, 0xff, 0x40, + 0x25, 0x70, 0x0, 0x7, 0xf8, 0x0, 0x1, 0xff, + 0xf6, 0x8f, 0xff, 0x0, 0x0, 0x7f, 0x80, 0x0, + 0xf, 0xff, 0x55, 0xff, 0xf4, 0x0, 0x7, 0xf8, + 0x0, 0x2, 0xff, 0xf4, 0x1f, 0xff, 0xa0, 0x0, + 0x7f, 0x80, 0x0, 0x8f, 0xff, 0x0, 0xbf, 0xff, + 0x40, 0x7, 0xf8, 0x0, 0x3f, 0xff, 0x90, 0x3, + 0xff, 0xff, 0x60, 0x7f, 0x80, 0x6f, 0xff, 0xf2, + 0x0, 0x6, 0xff, 0xff, 0xed, 0xfe, 0xef, 0xff, + 0xf5, 0x0, 0x0, 0x5, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xe4, 0x0, 0x0, 0x0, 0x0, 0x6b, 0xef, + 0xff, 0xec, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x84, 0x0, + 0x0, 0x0, 0x0, + + /* U+0025 "%" */ + 0x0, 0x6, 0xcf, 0xfc, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xfc, 0x10, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xe0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xd6, 0x5b, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x1f, 0xfe, 0x10, + 0x0, 0xbf, 0xf4, 0x0, 0x0, 0x0, 0xd, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf8, 0x0, 0x0, + 0x4f, 0xf9, 0x0, 0x0, 0x0, 0x6f, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf5, 0x0, 0x0, 0x1f, + 0xfc, 0x0, 0x0, 0x0, 0xef, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xf3, 0x0, 0x0, 0xf, 0xfe, + 0x0, 0x0, 0x6, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xf3, 0x0, 0x0, 0xf, 0xfe, 0x0, + 0x0, 0xe, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf4, 0x0, 0x0, 0x1f, 0xfd, 0x0, 0x0, + 0x7f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xf6, 0x0, 0x0, 0x4f, 0xfa, 0x0, 0x1, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xfc, + 0x0, 0x0, 0x9f, 0xf5, 0x0, 0x8, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0x81, + 0x7, 0xff, 0xd0, 0x0, 0x1f, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, + 0xfe, 0x30, 0x0, 0x9f, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1a, 0xff, 0xff, 0xb2, + 0x0, 0x2, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x13, 0x31, 0x0, 0x0, + 0xa, 0xff, 0x10, 0x0, 0x19, 0xef, 0xeb, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xf9, 0x0, 0x3, 0xef, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf1, + 0x0, 0xe, 0xff, 0x95, 0x6e, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0x80, 0x0, + 0x7f, 0xf9, 0x0, 0x2, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xfe, 0x10, 0x0, 0xcf, + 0xf2, 0x0, 0x0, 0xbf, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xf7, 0x0, 0x0, 0xff, 0xe0, + 0x0, 0x0, 0x7f, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xe0, 0x0, 0x1, 0xff, 0xc0, 0x0, + 0x0, 0x6f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0x60, 0x0, 0x1, 0xff, 0xc0, 0x0, 0x0, + 0x6f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xd, 0xfe, + 0x0, 0x0, 0x0, 0xff, 0xd0, 0x0, 0x0, 0x7f, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf6, 0x0, + 0x0, 0x0, 0xdf, 0xf0, 0x0, 0x0, 0xaf, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xd0, 0x0, 0x0, + 0x0, 0x9f, 0xf5, 0x0, 0x1, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x2f, 0xfe, 0x40, 0x2b, 0xff, 0x70, 0x0, 0x0, + 0x0, 0xe, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4d, + 0xff, 0xfe, 0x70, 0x0, 0x0, 0x0, 0x0, 0x34, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x24, + 0x30, 0x0, 0x0, + + /* U+0026 "&" */ + 0x0, 0x0, 0x0, 0x4, 0xae, 0xff, 0xc7, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xce, 0xff, 0xfe, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x90, 0x0, 0x6f, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xfc, 0x0, 0x0, 0x9, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf8, + 0x0, 0x0, 0x5, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xfa, 0x0, 0x0, 0x6, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0x10, 0x0, 0xc, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xc0, 0x0, 0x7f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xfa, 0x19, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xa1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xef, 0xff, + 0xdf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf7, 0x7, 0xff, 0xfe, 0x20, + 0x0, 0x97, 0x40, 0x0, 0x2, 0xff, 0xff, 0x40, + 0x0, 0x9f, 0xff, 0xd1, 0x3, 0xff, 0xf7, 0x0, + 0xa, 0xff, 0xf4, 0x0, 0x0, 0xb, 0xff, 0xfb, + 0x8, 0xff, 0xf2, 0x0, 0x1f, 0xff, 0xa0, 0x0, + 0x0, 0x1, 0xdf, 0xff, 0x9e, 0xff, 0xd0, 0x0, + 0x4f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x2e, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x5f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x3f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xf6, 0x0, 0x0, 0xf, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, 0x20, 0x0, + 0x9, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0xe2, 0x0, 0x1, 0xef, 0xff, 0xc4, + 0x0, 0x16, 0xdf, 0xff, 0xcc, 0xff, 0xfe, 0x40, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x1, 0xdf, 0xff, 0xf3, 0x0, 0x2, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x1c, 0xff, 0xa0, + 0x0, 0x0, 0x5, 0xad, 0xff, 0xdb, 0x61, 0x0, + 0x0, 0x0, 0xac, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0027 "'" */ + 0x4f, 0xff, 0x84, 0xff, 0xf8, 0x4f, 0xff, 0x84, + 0xff, 0xf8, 0x4f, 0xff, 0x81, 0xff, 0xf5, 0xf, + 0xff, 0x20, 0xcf, 0xf0, 0x9, 0xfd, 0x0, 0x48, + 0x60, + + /* U+0028 "(" */ + 0x0, 0x0, 0x0, 0x7f, 0xe1, 0x0, 0x0, 0x3, + 0xff, 0x50, 0x0, 0x0, 0xd, 0xfc, 0x0, 0x0, + 0x0, 0x8f, 0xf3, 0x0, 0x0, 0x2, 0xff, 0xb0, + 0x0, 0x0, 0xb, 0xff, 0x40, 0x0, 0x0, 0x3f, + 0xfd, 0x0, 0x0, 0x0, 0xaf, 0xf7, 0x0, 0x0, + 0x1, 0xff, 0xf2, 0x0, 0x0, 0x6, 0xff, 0xd0, + 0x0, 0x0, 0xb, 0xff, 0x80, 0x0, 0x0, 0xf, + 0xff, 0x50, 0x0, 0x0, 0x3f, 0xff, 0x20, 0x0, + 0x0, 0x6f, 0xff, 0x0, 0x0, 0x0, 0x8f, 0xfd, + 0x0, 0x0, 0x0, 0xaf, 0xfc, 0x0, 0x0, 0x0, + 0xaf, 0xfc, 0x0, 0x0, 0x0, 0xaf, 0xfc, 0x0, + 0x0, 0x0, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x8f, + 0xfd, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x20, 0x0, 0x0, 0xf, 0xff, + 0x50, 0x0, 0x0, 0xc, 0xff, 0x80, 0x0, 0x0, + 0x7, 0xff, 0xd0, 0x0, 0x0, 0x1, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0xaf, 0xf7, 0x0, 0x0, 0x0, + 0x3f, 0xfd, 0x0, 0x0, 0x0, 0xb, 0xff, 0x40, + 0x0, 0x0, 0x3, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x9f, 0xf3, 0x0, 0x0, 0x0, 0xe, 0xfc, 0x0, + 0x0, 0x0, 0x3, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x7f, 0xe1, + + /* U+0029 ")" */ + 0x5f, 0xf2, 0x0, 0x0, 0x0, 0xb, 0xfd, 0x0, + 0x0, 0x0, 0x2, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x9f, 0xf3, 0x0, 0x0, 0x0, 0x1f, 0xfc, 0x0, + 0x0, 0x0, 0xa, 0xff, 0x50, 0x0, 0x0, 0x3, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0xdf, 0xf4, 0x0, + 0x0, 0x0, 0x7f, 0xfb, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0x10, 0x0, 0x0, 0xe, 0xff, 0x60, 0x0, + 0x0, 0xa, 0xff, 0xa0, 0x0, 0x0, 0x7, 0xff, + 0xe0, 0x0, 0x0, 0x5, 0xff, 0xf0, 0x0, 0x0, + 0x3, 0xff, 0xf3, 0x0, 0x0, 0x2, 0xff, 0xf4, + 0x0, 0x0, 0x1, 0xff, 0xf5, 0x0, 0x0, 0x1, + 0xff, 0xf5, 0x0, 0x0, 0x2, 0xff, 0xf4, 0x0, + 0x0, 0x3, 0xff, 0xf3, 0x0, 0x0, 0x5, 0xff, + 0xf1, 0x0, 0x0, 0x7, 0xff, 0xe0, 0x0, 0x0, + 0xb, 0xff, 0xa0, 0x0, 0x0, 0xe, 0xff, 0x60, + 0x0, 0x0, 0x3f, 0xff, 0x10, 0x0, 0x0, 0x7f, + 0xfb, 0x0, 0x0, 0x0, 0xdf, 0xf4, 0x0, 0x0, + 0x3, 0xff, 0xc0, 0x0, 0x0, 0xa, 0xff, 0x50, + 0x0, 0x0, 0x1f, 0xfc, 0x0, 0x0, 0x0, 0x9f, + 0xf3, 0x0, 0x0, 0x2, 0xff, 0x90, 0x0, 0x0, + 0xb, 0xfd, 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x0, + 0x0, 0x0, + + /* U+002A "*" */ + 0x0, 0x0, 0xf, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xa0, 0x0, 0x0, 0x1, 0x0, 0xc, + 0xf8, 0x0, 0x1, 0x1, 0xfb, 0x40, 0xbf, 0x60, + 0x6c, 0xe0, 0x7f, 0xff, 0xdd, 0xfb, 0xef, 0xff, + 0x35, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xb3, 0x0, + 0x2, 0xaf, 0xff, 0x72, 0x0, 0x0, 0x0, 0x3f, + 0xfe, 0xfd, 0x10, 0x0, 0x0, 0x2e, 0xfc, 0x2f, + 0xfd, 0x0, 0x0, 0xd, 0xff, 0x30, 0x7f, 0xfb, + 0x0, 0x0, 0x7f, 0x90, 0x0, 0xce, 0x50, 0x0, + 0x0, 0x30, 0x0, 0x2, 0x10, 0x0, + + /* U+002B "+" */ + 0x0, 0x0, 0x0, 0x6, 0xdd, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x1, 0x11, 0x11, 0x11, 0x8f, 0xfb, + 0x11, 0x11, 0x11, 0x10, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x1e, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x7f, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfa, 0x0, + 0x0, 0x0, 0x0, + + /* U+002C "," */ + 0x8c, 0xcc, 0x1b, 0xff, 0xf1, 0xbf, 0xff, 0x1b, + 0xff, 0xf1, 0x0, 0xdf, 0x0, 0xf, 0xf0, 0x6, + 0xfa, 0x5, 0xff, 0x30, 0x8f, 0x50, 0x0, 0x10, + 0x0, + + /* U+002D "-" */ + 0x45, 0x55, 0x55, 0x55, 0x55, 0x2c, 0xff, 0xff, + 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0x7c, 0xff, 0xff, 0xff, 0xff, 0xf7, + + /* U+002E "." */ + 0x7c, 0xcc, 0x2a, 0xff, 0xf3, 0xaf, 0xff, 0x3a, + 0xff, 0xf3, + + /* U+002F "/" */ + 0x0, 0x0, 0x0, 0x4, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x8f, 0xf2, 0x0, 0x0, 0x0, 0xd, 0xfd, + 0x0, 0x0, 0x0, 0x2, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x6f, 0xf3, 0x0, 0x0, 0x0, 0xb, 0xff, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x4f, 0xf5, 0x0, 0x0, 0x0, 0x9, 0xff, + 0x10, 0x0, 0x0, 0x0, 0xef, 0xc0, 0x0, 0x0, + 0x0, 0x2f, 0xf7, 0x0, 0x0, 0x0, 0x7, 0xff, + 0x30, 0x0, 0x0, 0x0, 0xcf, 0xe0, 0x0, 0x0, + 0x0, 0x1f, 0xf9, 0x0, 0x0, 0x0, 0x5, 0xff, + 0x50, 0x0, 0x0, 0x0, 0xaf, 0xf0, 0x0, 0x0, + 0x0, 0xe, 0xfb, 0x0, 0x0, 0x0, 0x3, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x8f, 0xf2, 0x0, 0x0, + 0x0, 0xc, 0xfd, 0x0, 0x0, 0x0, 0x1, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x6f, 0xf4, 0x0, 0x0, + 0x0, 0xa, 0xff, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x4f, 0xf6, 0x0, 0x0, + 0x0, 0x9, 0xff, 0x20, 0x0, 0x0, 0x0, 0xdf, + 0xd0, 0x0, 0x0, 0x0, 0x0, + + /* U+0030 "0" */ + 0x0, 0x0, 0x1, 0x7c, 0xef, 0xec, 0x71, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xdc, + 0xdf, 0xff, 0xf6, 0x0, 0x0, 0x3, 0xff, 0xfd, + 0x30, 0x0, 0x3d, 0xff, 0xf3, 0x0, 0x0, 0xbf, + 0xfe, 0x10, 0x0, 0x0, 0x1d, 0xff, 0xb0, 0x0, + 0x2f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x30, 0x7, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xf8, 0x0, 0xcf, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xc0, 0xe, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x1, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf1, 0x3f, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x44, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xf4, 0x4f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x55, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xf6, 0x4f, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x54, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf4, + 0x3f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0x41, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xf1, 0xe, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x0, 0xcf, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xc0, 0x7, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf8, 0x0, + 0x2f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x30, 0x0, 0xbf, 0xfe, 0x10, 0x0, 0x0, 0x1d, + 0xff, 0xc0, 0x0, 0x3, 0xff, 0xfd, 0x30, 0x0, + 0x3d, 0xff, 0xf3, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xdb, 0xdf, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x7c, 0xef, 0xec, 0x71, 0x0, 0x0, + 0x0, + + /* U+0031 "1" */ + 0x0, 0x0, 0x0, 0x4, 0xff, 0x30, 0x0, 0x0, + 0x0, 0xdf, 0xf3, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x30, 0x0, 0x0, 0xbf, 0xff, 0xf3, 0x0, 0x2, + 0xdf, 0xff, 0xff, 0x30, 0x7, 0xff, 0xff, 0xff, + 0xf3, 0x5e, 0xff, 0xff, 0x6f, 0xff, 0x3c, 0xff, + 0xfc, 0x21, 0xff, 0xf3, 0xcf, 0xe6, 0x0, 0x1f, + 0xff, 0x39, 0x60, 0x0, 0x1, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x30, 0x0, 0x0, 0x1, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x30, + 0x0, 0x0, 0x1, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x30, 0x0, 0x0, 0x1, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x30, 0x0, 0x0, + 0x1, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0x30, 0x0, 0x0, 0x1, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x30, 0x0, 0x0, 0x1, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x30, 0x0, + 0x0, 0x1, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x30, 0x0, 0x0, 0x1, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x30, + + /* U+0032 "2" */ + 0x0, 0x0, 0x3, 0x8c, 0xef, 0xed, 0x94, 0x0, + 0x0, 0x0, 0x0, 0x1b, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x20, 0x0, 0x0, 0x2e, 0xff, 0xff, 0xdc, + 0xdf, 0xff, 0xff, 0x30, 0x0, 0xc, 0xff, 0xf9, + 0x10, 0x0, 0x18, 0xff, 0xfe, 0x0, 0x6, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf7, 0x0, + 0xbf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xd0, 0xf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x1, 0xdf, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xcf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xdf, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xef, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xfe, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xfc, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x43, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x30, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x2a, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x20, + + /* U+0033 "3" */ + 0x0, 0x0, 0x3, 0x9d, 0xff, 0xeb, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x1b, 0xff, 0xff, 0xff, 0xff, + 0xe5, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xcb, + 0xef, 0xff, 0xf6, 0x0, 0x0, 0xb, 0xff, 0xf7, + 0x0, 0x0, 0x3d, 0xff, 0xf3, 0x0, 0x4, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xb0, 0x0, + 0xaf, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0x0, 0xc, 0xff, 0x80, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf1, 0x0, 0x0, 0x31, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x5c, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xe6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xfe, 0x92, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8a, + 0x89, 0xdf, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4e, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x72, 0xac, 0xe2, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf6, 0x2f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x40, + 0xdf, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf0, 0x7, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xf7, 0x0, 0xd, 0xff, 0xf9, 0x10, 0x0, + 0x2b, 0xff, 0xfc, 0x0, 0x0, 0x1e, 0xff, 0xff, + 0xdc, 0xef, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x1b, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x3, 0x9d, 0xff, 0xec, 0x71, 0x0, 0x0, + 0x0, + + /* U+0034 "4" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xef, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xfa, 0xaf, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xe1, 0xaf, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0x40, 0xaf, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf9, 0x0, + 0xaf, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xe0, 0x0, 0xaf, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0x40, 0x0, 0xaf, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xf9, 0x0, 0x0, 0xaf, 0xfb, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xd0, 0x0, 0x0, + 0xaf, 0xfb, 0x0, 0x0, 0x0, 0x1e, 0xff, 0x30, + 0x0, 0x0, 0xaf, 0xfb, 0x0, 0x0, 0x0, 0xbf, + 0xf8, 0x0, 0x0, 0x0, 0xaf, 0xfb, 0x0, 0x0, + 0x6, 0xff, 0xd0, 0x0, 0x0, 0x0, 0xaf, 0xfb, + 0x0, 0x0, 0x2f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0xaf, 0xfb, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xfb, 0x0, 0x0, + + /* U+0035 "5" */ + 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0xcf, 0xf8, + 0x22, 0x22, 0x22, 0x22, 0x22, 0x10, 0x0, 0xf, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0x52, 0x8c, 0xff, 0xea, 0x50, 0x0, 0x0, 0x1, + 0xff, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xd3, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf4, 0x0, 0x7, 0xff, 0xff, 0x93, 0x0, 0x4, + 0xbf, 0xff, 0xf2, 0x0, 0xaf, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xb0, 0x1, 0x35, 0x40, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0x92, 0x78, 0xa2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf7, 0x3f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x30, + 0xef, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xd0, 0x9, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xf6, 0x0, 0x1e, 0xff, 0xf9, 0x10, 0x0, + 0x1a, 0xff, 0xfb, 0x0, 0x0, 0x3e, 0xff, 0xff, + 0xcb, 0xdf, 0xff, 0xfc, 0x10, 0x0, 0x0, 0x2b, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x3, 0x9d, 0xff, 0xec, 0x82, 0x0, 0x0, + 0x0, + + /* U+0036 "6" */ + 0x0, 0x0, 0x0, 0x38, 0xde, 0xfe, 0xb7, 0x10, + 0x0, 0x0, 0x0, 0x1, 0xaf, 0xff, 0xff, 0xff, + 0xfe, 0x50, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xfc, + 0xce, 0xff, 0xff, 0x60, 0x0, 0x0, 0xcf, 0xff, + 0x60, 0x0, 0x5, 0xef, 0xff, 0x20, 0x0, 0x7f, + 0xff, 0x30, 0x0, 0x0, 0x4, 0xff, 0xf9, 0x0, + 0xf, 0xff, 0x70, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xe0, 0x5, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x38, 0x76, 0x0, 0xaf, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf2, + 0x0, 0x6b, 0xef, 0xeb, 0x60, 0x0, 0x0, 0x3f, + 0xff, 0x3, 0xdf, 0xff, 0xff, 0xff, 0xd3, 0x0, + 0x4, 0xff, 0xf3, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x5f, 0xff, 0xef, 0xf7, 0x10, 0x3, + 0xaf, 0xff, 0xe1, 0x6, 0xff, 0xff, 0xe2, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x90, 0x6f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x6, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf4, + 0x5f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x63, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xf8, 0x1f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0x70, 0xef, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf6, 0xa, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x20, + 0x4f, 0xff, 0x60, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xd0, 0x0, 0xdf, 0xff, 0x20, 0x0, 0x0, 0x6, + 0xff, 0xf6, 0x0, 0x3, 0xff, 0xfe, 0x50, 0x0, + 0x7, 0xff, 0xfc, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xec, 0xcf, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x3, + 0xcf, 0xff, 0xff, 0xff, 0xfc, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x4a, 0xdf, 0xfd, 0xa5, 0x0, 0x0, + 0x0, + + /* U+0037 "7" */ + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x72, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf7, 0x2f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x60, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x4f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+0038 "8" */ + 0x0, 0x0, 0x2, 0x8c, 0xef, 0xec, 0x82, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xdb, + 0xdf, 0xff, 0xfc, 0x0, 0x0, 0x6, 0xff, 0xfb, + 0x20, 0x0, 0x1a, 0xff, 0xf9, 0x0, 0x0, 0xdf, + 0xfc, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf1, 0x0, + 0x2f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x40, 0x4, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf6, 0x0, 0x3f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0x40, 0x1, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf1, 0x0, 0xa, 0xff, + 0xfb, 0x10, 0x0, 0x19, 0xff, 0xf6, 0x0, 0x0, + 0x1d, 0xff, 0xff, 0xdb, 0xcf, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x19, 0xff, 0xff, 0xff, 0xff, 0xd2, + 0x0, 0x0, 0x0, 0x0, 0x5c, 0xff, 0xff, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x2, 0xdf, 0xfd, 0x51, + 0x1, 0x5d, 0xff, 0xf9, 0x0, 0x1, 0xdf, 0xfb, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf5, 0x0, 0x9f, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xd0, + 0xf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x34, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf7, 0x5f, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0x85, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf7, 0x3f, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x50, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf1, 0x9, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xfa, 0x0, 0x1e, 0xff, 0xfa, 0x10, 0x0, + 0x8, 0xff, 0xfe, 0x10, 0x0, 0x2e, 0xff, 0xff, + 0xdb, 0xcf, 0xff, 0xfe, 0x30, 0x0, 0x0, 0x1b, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0x10, 0x0, 0x0, + 0x0, 0x3, 0x8c, 0xef, 0xed, 0x93, 0x0, 0x0, + 0x0, + + /* U+0039 "9" */ + 0x0, 0x0, 0x4, 0x9d, 0xff, 0xda, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x1b, 0xff, 0xff, 0xff, 0xff, + 0xd4, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xdc, + 0xdf, 0xff, 0xf6, 0x0, 0x0, 0xc, 0xff, 0xfb, + 0x20, 0x0, 0x1a, 0xff, 0xf5, 0x0, 0x6, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x9, 0xff, 0xe0, 0x0, + 0xdf, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0x60, 0x1f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfc, 0x4, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf0, 0x5f, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x34, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf5, 0x2f, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0x60, 0xef, 0xfc, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf7, 0x8, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0x80, 0x1e, 0xff, 0xfc, 0x40, + 0x0, 0x4b, 0xff, 0xef, 0xf8, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x5c, 0xff, 0x70, 0x0, + 0x2d, 0xff, 0xff, 0xff, 0xfe, 0x40, 0xdf, 0xf6, + 0x0, 0x0, 0x5, 0xbe, 0xff, 0xc7, 0x0, 0xe, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0x0, 0x0, 0x21, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xc0, 0xb, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf8, 0x0, + 0x9f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0x20, 0x3, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xa0, 0x0, 0xb, 0xff, 0xf5, 0x0, 0x0, + 0x6f, 0xff, 0xe1, 0x0, 0x0, 0x2e, 0xff, 0xfe, + 0xbc, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x2d, + 0xff, 0xff, 0xff, 0xff, 0xb1, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xbe, 0xfe, 0xd9, 0x40, 0x0, 0x0, + 0x0, + + /* U+003A ":" */ + 0xaf, 0xff, 0x3a, 0xff, 0xf3, 0xaf, 0xff, 0x37, + 0xcc, 0xc2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7c, 0xcc, 0x2a, 0xff, 0xf3, 0xaf, 0xff, 0x3a, + 0xff, 0xf3, + + /* U+003B ";" */ + 0xbf, 0xff, 0x1b, 0xff, 0xf1, 0xbf, 0xff, 0x18, + 0xcc, 0xc1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8c, 0xcc, 0x1b, 0xff, 0xf1, 0xbf, 0xff, 0x1b, + 0xff, 0xf1, 0x0, 0xdf, 0x0, 0xf, 0xf0, 0x6, + 0xfa, 0x5, 0xff, 0x30, 0x8f, 0x50, 0x0, 0x10, + 0x0, + + /* U+003C "<" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5c, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x18, 0xef, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xaf, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x6d, 0xff, 0xff, 0xfe, 0x81, 0x0, + 0x0, 0x0, 0x29, 0xff, 0xff, 0xff, 0xb5, 0x0, + 0x0, 0x0, 0x5, 0xbf, 0xff, 0xff, 0xe8, 0x20, + 0x0, 0x0, 0x1, 0x7e, 0xff, 0xff, 0xfc, 0x50, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0x92, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xfa, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xcf, 0xff, 0xff, 0xd6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3a, 0xff, 0xff, 0xff, 0x92, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x7e, 0xff, + 0xff, 0xfc, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xcf, 0xff, 0xff, 0xe8, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x39, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x7e, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xbf, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x29, 0x10, + + /* U+003D "=" */ + 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, + 0x11, 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf1, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x1e, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x11, 0x11, 0x11, 0x11, + 0x11, 0x11, 0x11, 0x11, 0x11, 0xe, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x1e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf1, + + /* U+003E ">" */ + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xd6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x92, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xfc, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x16, 0xdf, + 0xff, 0xff, 0xe7, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4a, 0xff, 0xff, 0xff, 0xa3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x7d, 0xff, 0xff, 0xfd, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xbf, + 0xff, 0xff, 0xf9, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x18, 0xef, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x8e, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x5b, 0xff, 0xff, + 0xfd, 0x70, 0x0, 0x0, 0x0, 0x18, 0xef, 0xff, + 0xff, 0xb5, 0x0, 0x0, 0x0, 0x4, 0xaf, 0xff, + 0xff, 0xf9, 0x20, 0x0, 0x0, 0x1, 0x7d, 0xff, + 0xff, 0xfd, 0x60, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0xb4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xe8, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xfd, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x94, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+003F "?" */ + 0x0, 0x0, 0x3, 0x9c, 0xef, 0xed, 0x94, 0x0, + 0x0, 0x0, 0x0, 0x1b, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x20, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xdc, + 0xdf, 0xff, 0xff, 0x40, 0x0, 0xc, 0xff, 0xfa, + 0x10, 0x0, 0x18, 0xff, 0xff, 0x20, 0x6, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfb, 0x0, + 0xcf, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf1, 0xf, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x32, 0xce, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x66, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4c, 0xcc, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, + + /* U+0040 "@" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x37, 0xac, + 0xef, 0xff, 0xec, 0xa6, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x8e, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xfe, 0xcb, 0xbc, 0xdf, 0xff, + 0xff, 0xfc, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2d, 0xff, 0xff, 0xa5, 0x10, 0x0, 0x0, + 0x0, 0x37, 0xef, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x91, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xef, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, 0xd3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1a, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfc, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x10, 0x0, 0x0, 0xa, + 0xff, 0xc0, 0x0, 0x0, 0x2, 0x8d, 0xfe, 0xc5, + 0x0, 0xf, 0xff, 0x40, 0x9, 0xff, 0xa0, 0x0, + 0x0, 0x4f, 0xfe, 0x10, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xb1, 0x3f, 0xff, 0x10, 0x0, 0xef, + 0xf3, 0x0, 0x0, 0xcf, 0xf4, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xdc, 0xff, 0xfc, 0x6f, 0xfe, 0x0, + 0x0, 0x5f, 0xf9, 0x0, 0x4, 0xff, 0xa0, 0x0, + 0x0, 0xaf, 0xff, 0x91, 0x0, 0x8, 0xff, 0xef, + 0xfa, 0x0, 0x0, 0xf, 0xfe, 0x0, 0xa, 0xff, + 0x20, 0x0, 0x6, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xf7, 0x0, 0x0, 0xa, 0xff, 0x20, + 0xf, 0xfc, 0x0, 0x0, 0x1f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xf4, 0x0, 0x0, 0x8, + 0xff, 0x40, 0x4f, 0xf7, 0x0, 0x0, 0x8f, 0xff, + 0x20, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf0, 0x0, + 0x0, 0x6, 0xff, 0x50, 0x8f, 0xf3, 0x0, 0x0, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xd0, 0x0, 0x0, 0x6, 0xff, 0x50, 0xaf, 0xf1, + 0x0, 0x4, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0x90, 0x0, 0x0, 0x7, 0xff, 0x40, + 0xcf, 0xf0, 0x0, 0x8, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0x60, 0x0, 0x0, 0xa, + 0xff, 0x20, 0xdf, 0xe0, 0x0, 0xa, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0x30, 0x0, + 0x0, 0xf, 0xfe, 0x0, 0xdf, 0xf0, 0x0, 0xc, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x0, 0x0, 0x0, 0x6f, 0xf9, 0x0, 0xcf, 0xf0, + 0x0, 0xb, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xfc, 0x0, 0x0, 0x0, 0xdf, 0xf2, 0x0, + 0xaf, 0xf2, 0x0, 0xa, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xf9, 0x0, 0x0, 0x8, 0xff, + 0xa0, 0x0, 0x8f, 0xf5, 0x0, 0x6, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf5, 0x0, 0x0, + 0x5f, 0xfe, 0x20, 0x0, 0x4f, 0xfa, 0x0, 0x1, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf3, + 0x0, 0x7, 0xff, 0xf5, 0x0, 0x0, 0xf, 0xff, + 0x0, 0x0, 0x9f, 0xff, 0x80, 0x0, 0x3c, 0xff, + 0xff, 0xf9, 0x15, 0xcf, 0xff, 0x70, 0x0, 0x0, + 0xa, 0xff, 0x80, 0x0, 0xd, 0xff, 0xfe, 0xcd, + 0xff, 0xe6, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xf2, 0x0, 0x1, 0xdf, + 0xff, 0xff, 0xfc, 0x20, 0xef, 0xff, 0xff, 0xfd, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfd, 0x0, + 0x0, 0x7, 0xcf, 0xec, 0x60, 0x0, 0x2b, 0xef, + 0xda, 0x40, 0x0, 0x1, 0x66, 0x61, 0x0, 0x1d, + 0xff, 0xc1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xa0, + 0x0, 0x2, 0xef, 0xfe, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xef, + 0xfc, 0x0, 0x0, 0x0, 0x3e, 0xff, 0xfb, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xcf, 0xff, 0xb1, 0x0, 0x0, 0x0, 0x1, 0xcf, + 0xff, 0xfe, 0x95, 0x20, 0x0, 0x0, 0x0, 0x1, + 0x59, 0xef, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xef, 0xff, 0xff, 0xff, 0xdc, 0xcc, + 0xcd, 0xff, 0xff, 0xff, 0xfb, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xe9, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x58, 0xbd, 0xef, 0xff, 0xee, 0xca, 0x73, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0041 "A" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xaf, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xe3, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xfa, 0xd, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x50, + 0x8f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf0, 0x2, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xfa, 0x0, 0xc, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x40, + 0x0, 0x6f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xe0, 0x0, 0x0, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf8, 0x0, 0x0, 0xa, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x20, + 0x0, 0x0, 0x4f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0xef, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xee, + 0xee, 0xee, 0xee, 0xee, 0xef, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x50, 0x0, 0x0, 0x8, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0xef, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf2, + 0x0, 0x0, 0x4f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x90, 0x0, 0xa, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0x0, 0x1, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf6, 0x0, 0x7f, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xd0, 0xd, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x30, + + /* U+0042 "B" */ + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xec, 0x94, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd4, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x3f, 0xff, 0x82, 0x22, 0x22, 0x33, 0x58, + 0xcf, 0xff, 0xf2, 0x0, 0x3f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf9, 0x0, 0x3f, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xfe, 0x0, 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x0, 0x3f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfe, 0x0, + 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xfb, 0x0, 0x3f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xf4, 0x0, 0x3f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x24, 0x9f, 0xff, 0x90, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb3, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x3f, 0xff, 0x83, 0x33, 0x33, 0x33, + 0x46, 0xbf, 0xff, 0xfb, 0x0, 0x3f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xcf, 0xff, 0x60, + 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xe0, 0x3f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf2, 0x3f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf4, 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xf4, 0x3f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf3, 0x3f, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xe0, 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xbf, 0xff, 0x90, 0x3f, 0xff, 0x83, + 0x33, 0x33, 0x33, 0x46, 0x9f, 0xff, 0xfe, 0x10, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x20, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xed, 0xb8, 0x30, 0x0, + 0x0, + + /* U+0043 "C" */ + 0x0, 0x0, 0x0, 0x0, 0x15, 0x9c, 0xef, 0xfe, + 0xb7, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa1, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xe9, 0x52, 0x11, 0x37, 0xef, 0xff, + 0xf4, 0x0, 0x0, 0x4, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xe1, 0x0, 0x1, + 0xef, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xa0, 0x0, 0x8f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x10, + 0x1f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xe4, 0x5, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0x20, + 0x0, 0x9f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x66, + 0x20, 0x4, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xc0, 0xe, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf9, 0x0, 0x7f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x30, 0x0, + 0xef, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xa0, 0x0, 0x4, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x1, 0xaf, 0xff, 0xe1, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xe8, 0x32, 0x11, 0x49, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe3, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x91, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x26, 0xbd, 0xef, 0xfd, 0xb7, 0x10, 0x0, + 0x0, 0x0, + + /* U+0044 "D" */ + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xed, 0xb8, + 0x30, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x30, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0xf, 0xff, 0xa2, 0x22, + 0x22, 0x23, 0x46, 0xae, 0xff, 0xff, 0x40, 0x0, + 0xf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xf2, 0x0, 0xf, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfa, 0x0, + 0xf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x20, 0xf, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x90, + 0xf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xd0, 0xf, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf1, + 0xf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf4, 0xf, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf5, + 0xf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf6, 0xf, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf7, + 0xf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf6, 0xf, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf5, + 0xf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf3, 0xf, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf1, + 0xf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xd0, 0xf, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x80, + 0xf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x20, 0xf, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfa, 0x0, + 0xf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xaf, 0xff, 0xe1, 0x0, 0xf, 0xff, 0xa3, 0x33, + 0x33, 0x33, 0x47, 0xaf, 0xff, 0xff, 0x40, 0x0, + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x20, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xec, 0xa6, + 0x10, 0x0, 0x0, 0x0, + + /* U+0045 "E" */ + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xa0, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0xf, + 0xff, 0xa2, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x10, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xa2, 0x22, 0x22, + 0x22, 0x22, 0x22, 0x22, 0x21, 0x0, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xa0, 0xf, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xa3, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x30, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x50, + + /* U+0046 "F" */ + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x6f, 0xff, 0xb2, 0x22, + 0x22, 0x22, 0x22, 0x22, 0x22, 0x21, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xb3, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x31, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x60, 0xf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf6, 0x0, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0xf, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+0047 "G" */ + 0x0, 0x0, 0x0, 0x0, 0x3, 0x7b, 0xde, 0xff, + 0xeb, 0x83, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x1, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x3, 0xef, 0xff, 0xfb, 0x73, 0x21, + 0x13, 0x6c, 0xff, 0xff, 0x90, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xb2, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xef, 0xff, 0x50, 0x0, 0x0, 0xbf, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, 0xfe, + 0x0, 0x0, 0x5f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf5, 0x0, 0xc, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xfe, 0x70, 0x3, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x32, + 0x0, 0x0, 0x7f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x12, 0x22, 0x22, 0x22, 0x22, 0x22, 0x0, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf2, 0xf, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x20, 0xef, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + 0xc, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x20, 0x8f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xf2, 0x4, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x20, 0xd, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf2, 0x0, 0x5f, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0x20, 0x0, 0xcf, 0xff, 0xc1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3d, 0xff, + 0xf2, 0x0, 0x1, 0xef, 0xff, 0xe6, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xaf, 0xff, 0xff, 0x10, 0x0, + 0x2, 0xdf, 0xff, 0xfe, 0xa6, 0x43, 0x46, 0x9e, + 0xff, 0xff, 0xfe, 0x40, 0x0, 0x0, 0x1, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x4c, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x92, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0x6a, 0xde, 0xff, 0xec, + 0x95, 0x0, 0x0, 0x0, 0x0, + + /* U+0048 "H" */ + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf6, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf6, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf6, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf6, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf6, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf6, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf6, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0xff, 0xfb, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x35, 0xff, 0xf6, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf6, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf6, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf6, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf6, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf6, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf6, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf6, + + /* U+0049 "I" */ + 0x8f, 0xff, 0x18, 0xff, 0xf1, 0x8f, 0xff, 0x18, + 0xff, 0xf1, 0x8f, 0xff, 0x18, 0xff, 0xf1, 0x8f, + 0xff, 0x18, 0xff, 0xf1, 0x8f, 0xff, 0x18, 0xff, + 0xf1, 0x8f, 0xff, 0x18, 0xff, 0xf1, 0x8f, 0xff, + 0x18, 0xff, 0xf1, 0x8f, 0xff, 0x18, 0xff, 0xf1, + 0x8f, 0xff, 0x18, 0xff, 0xf1, 0x8f, 0xff, 0x18, + 0xff, 0xf1, 0x8f, 0xff, 0x18, 0xff, 0xf1, 0x8f, + 0xff, 0x18, 0xff, 0xf1, 0x8f, 0xff, 0x18, 0xff, + 0xf1, 0x8f, 0xff, 0x10, + + /* U+004A "J" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, + 0x13, 0x52, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, + 0xef, 0xf6, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf0, + 0xdf, 0xf9, 0x0, 0x0, 0x0, 0xb, 0xff, 0xe0, + 0xbf, 0xfd, 0x0, 0x0, 0x0, 0xf, 0xff, 0xb0, + 0x7f, 0xff, 0x70, 0x0, 0x0, 0x7f, 0xff, 0x70, + 0x1f, 0xff, 0xf9, 0x43, 0x49, 0xff, 0xff, 0x10, + 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x2, 0x8d, 0xef, 0xec, 0x71, 0x0, 0x0, + + /* U+004B "K" */ + 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0x40, 0x3f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf4, 0x0, + 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0x30, 0x0, 0x3f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xe3, 0x0, 0x0, + 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xfe, 0x20, 0x0, 0x0, 0x3f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xe2, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x60, 0x0, 0x0, 0xa, 0xff, 0xfd, + 0x20, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x60, 0x0, + 0x0, 0xaf, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x60, 0x0, 0xa, 0xff, 0xfd, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x60, 0x0, + 0xaf, 0xff, 0xc1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x60, 0xa, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x60, 0xaf, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x6a, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xef, 0xff, + 0xae, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xfa, 0x5, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0x90, + 0x0, 0x9f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf9, 0x0, 0x0, 0xd, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x90, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x3f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf3, 0x0, 0x0, + 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfe, 0x10, 0x0, 0x3f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xb0, 0x0, + 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf7, 0x0, 0x3f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x30, + 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xd0, + + /* U+004C "L" */ + 0x2f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0x83, 0x33, 0x33, 0x33, 0x33, 0x33, 0x32, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, + + /* U+004D "M" */ + 0x2f, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xd2, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xfd, 0x2f, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xd2, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xfd, 0x2f, 0xff, + 0xdf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xfe, 0xff, 0xd2, 0xff, 0xf7, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xfe, 0xaf, + 0xfd, 0x2f, 0xff, 0x5d, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0x9a, 0xff, 0xd2, 0xff, + 0xf5, 0x7f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xf4, 0xaf, 0xfd, 0x2f, 0xff, 0x52, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0xf, 0xfe, 0xa, + 0xff, 0xd2, 0xff, 0xf5, 0xc, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x5, 0xff, 0x80, 0xaf, 0xfd, 0x2f, + 0xff, 0x50, 0x7f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xf3, 0xa, 0xff, 0xd2, 0xff, 0xf5, 0x1, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0xf, 0xfd, 0x0, + 0xaf, 0xfd, 0x2f, 0xff, 0x50, 0xc, 0xff, 0x70, + 0x0, 0x0, 0x5, 0xff, 0x80, 0xa, 0xff, 0xd2, + 0xff, 0xf5, 0x0, 0x6f, 0xfd, 0x0, 0x0, 0x0, + 0xbf, 0xf2, 0x0, 0xaf, 0xfd, 0x2f, 0xff, 0x50, + 0x1, 0xff, 0xf2, 0x0, 0x0, 0x1f, 0xfc, 0x0, + 0xa, 0xff, 0xd2, 0xff, 0xf5, 0x0, 0xb, 0xff, + 0x70, 0x0, 0x6, 0xff, 0x70, 0x0, 0xaf, 0xfd, + 0x2f, 0xff, 0x50, 0x0, 0x6f, 0xfd, 0x0, 0x0, + 0xcf, 0xf1, 0x0, 0xa, 0xff, 0xd2, 0xff, 0xf5, + 0x0, 0x1, 0xff, 0xf2, 0x0, 0x1f, 0xfc, 0x0, + 0x0, 0xaf, 0xfd, 0x2f, 0xff, 0x50, 0x0, 0xb, + 0xff, 0x80, 0x7, 0xff, 0x60, 0x0, 0xa, 0xff, + 0xd2, 0xff, 0xf5, 0x0, 0x0, 0x6f, 0xfd, 0x0, + 0xcf, 0xf1, 0x0, 0x0, 0xaf, 0xfd, 0x2f, 0xff, + 0x50, 0x0, 0x1, 0xff, 0xf2, 0x2f, 0xfb, 0x0, + 0x0, 0xa, 0xff, 0xd2, 0xff, 0xf5, 0x0, 0x0, + 0xb, 0xff, 0x77, 0xff, 0x50, 0x0, 0x0, 0xaf, + 0xfd, 0x2f, 0xff, 0x50, 0x0, 0x0, 0x5f, 0xfd, + 0xcf, 0xf0, 0x0, 0x0, 0xa, 0xff, 0xd2, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0xaf, 0xfd, 0x2f, 0xff, 0x50, 0x0, + 0x0, 0xa, 0xff, 0xff, 0x40, 0x0, 0x0, 0xa, + 0xff, 0xd2, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0xaf, 0xfd, 0x2f, + 0xff, 0x50, 0x0, 0x0, 0x0, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xd0, + + /* U+004E "N" */ + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf7, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf7, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf7, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf7, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf7, 0xff, 0xf9, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xf7, 0xff, 0xf7, 0x6f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf7, + 0xff, 0xf7, 0xb, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf7, 0xff, 0xf7, 0x1, 0xef, 0xff, + 0x20, 0x0, 0x0, 0x0, 0xff, 0xf7, 0xff, 0xf7, + 0x0, 0x5f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0xff, + 0xf7, 0xff, 0xf7, 0x0, 0xb, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0xff, 0xf7, 0xff, 0xf7, 0x0, 0x1, + 0xef, 0xff, 0x20, 0x0, 0x0, 0xff, 0xf7, 0xff, + 0xf7, 0x0, 0x0, 0x5f, 0xff, 0xc0, 0x0, 0x0, + 0xff, 0xf7, 0xff, 0xf7, 0x0, 0x0, 0xa, 0xff, + 0xf7, 0x0, 0x0, 0xff, 0xf7, 0xff, 0xf7, 0x0, + 0x0, 0x1, 0xef, 0xff, 0x20, 0x0, 0xff, 0xf7, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xc0, + 0x0, 0xff, 0xf7, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf7, 0x0, 0xff, 0xf7, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0x20, 0xff, + 0xf7, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xd0, 0xff, 0xf7, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xf8, 0xff, 0xf7, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xff, 0xf7, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xf7, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf7, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xf7, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf7, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf7, + + /* U+004F "O" */ + 0x0, 0x0, 0x0, 0x0, 0x5, 0x9c, 0xef, 0xfd, + 0xb7, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xfa, 0x53, 0x12, + 0x37, 0xcf, 0xff, 0xfc, 0x10, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xa1, 0x0, 0x0, 0x0, 0x0, 0x4e, + 0xff, 0xfc, 0x0, 0x0, 0x1, 0xef, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xf8, + 0x0, 0x0, 0x8f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xf2, 0x0, 0x1f, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x90, 0x6, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x0, 0xaf, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf4, 0xe, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0x80, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xfa, 0x1f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xb3, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xfc, 0x3f, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xb1, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfa, + 0xf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x80, 0xbf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xf4, 0x6, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x0, 0x1f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xa0, 0x0, 0x9f, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xf2, 0x0, 0x1, 0xef, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1c, 0xff, 0xf9, + 0x0, 0x0, 0x4, 0xff, 0xff, 0x91, 0x0, 0x0, + 0x0, 0x0, 0x4d, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xe9, 0x42, 0x11, 0x37, 0xcf, + 0xff, 0xfc, 0x10, 0x0, 0x0, 0x0, 0x4, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x8f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xad, 0xef, 0xfd, 0xb7, + 0x30, 0x0, 0x0, 0x0, 0x0, + + /* U+0050 "P" */ + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xda, + 0x72, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x1f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0x1f, 0xff, 0x92, 0x22, 0x22, 0x22, 0x34, + 0x6b, 0xff, 0xff, 0x80, 0x1f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf1, 0x1f, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf6, 0x1f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf9, 0x1f, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfa, + 0x1f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xfa, 0x1f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf8, 0x1f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf4, 0x1f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xd0, 0x1f, 0xff, 0x93, 0x33, + 0x33, 0x33, 0x35, 0x8e, 0xff, 0xff, 0x50, 0x1f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x50, 0x0, 0x1f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0xc9, 0x50, 0x0, 0x0, + 0x1f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+0051 "Q" */ + 0x0, 0x0, 0x0, 0x0, 0x15, 0x9c, 0xef, 0xfe, + 0xb8, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xa5, + 0x31, 0x23, 0x7c, 0xff, 0xff, 0xd1, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xa1, 0x0, 0x0, 0x0, + 0x0, 0x4d, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xcf, 0xff, 0x90, 0x0, 0x0, 0x8f, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xf2, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf9, 0x0, + 0x6, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x0, 0xb, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x40, 0xf, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x80, 0x1f, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xa0, + 0x2f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xb0, 0x3f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xc0, 0x2f, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xc0, 0xf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xa0, + 0xe, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x80, 0xa, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0x50, 0x6, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x0, 0x0, 0xef, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x49, 0x30, 0x0, 0x5, 0xff, 0xfa, 0x0, + 0x0, 0x8f, 0xff, 0x80, 0x0, 0x0, 0x0, 0xaf, + 0xfc, 0x30, 0x1e, 0xff, 0xf2, 0x0, 0x0, 0xd, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf8, + 0xcf, 0xff, 0x90, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x91, 0x0, 0x0, 0x4, 0xcf, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x94, + 0x21, 0x13, 0x7e, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x7f, 0xff, 0xfa, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x15, 0xac, 0xef, 0xfe, 0xb7, 0x20, 0x2, 0xcf, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xef, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0x30, + + /* U+0052 "R" */ + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xec, + 0x94, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x20, 0x0, + 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x20, 0x0, 0xf, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0x8f, 0xff, 0xfc, + 0x0, 0x0, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2e, 0xff, 0xf4, 0x0, 0xf, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x90, 0x0, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xfb, 0x0, 0xf, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xc0, 0x0, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfb, 0x0, + 0xf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x70, 0x0, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf1, + 0x0, 0xf, 0xff, 0xa1, 0x11, 0x11, 0x11, 0x12, + 0x37, 0xcf, 0xff, 0xf7, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd4, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc7, 0x20, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xa0, 0x0, 0x0, + 0x26, 0xef, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0x70, 0x0, 0x0, 0xf, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x30, + 0x0, 0x0, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xfd, 0x0, 0x0, 0xf, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xf7, 0x0, 0x0, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf2, 0x0, 0xf, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xc0, 0x0, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x60, + 0xf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x10, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xfb, 0x0, + + /* U+0053 "S" */ + 0x0, 0x0, 0x0, 0x28, 0xbe, 0xff, 0xed, 0xa7, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x1, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xa1, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe2, 0x0, 0x0, 0x1, 0xff, 0xff, 0xd8, 0x53, + 0x23, 0x59, 0xef, 0xff, 0xe1, 0x0, 0x0, 0xaf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xa0, 0x0, 0xf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x10, 0x2, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf5, + 0x0, 0x3f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0x60, 0x1, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x10, 0x0, 0x0, + 0xc, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xa5, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xd9, 0x61, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2c, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x83, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0x8d, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x59, 0xdf, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x15, 0xaf, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1a, 0xff, 0xfc, 0x0, 0x0, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf2, 0x3f, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x42, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf5, 0xe, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x30, 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xe0, 0x1, 0xef, 0xff, + 0xc3, 0x0, 0x0, 0x0, 0x0, 0x1b, 0xff, 0xf8, + 0x0, 0x4, 0xff, 0xff, 0xfc, 0x85, 0x33, 0x46, + 0xbf, 0xff, 0xfd, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x10, 0x0, + 0x0, 0x1, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x16, 0xad, + 0xef, 0xfe, 0xda, 0x60, 0x0, 0x0, 0x0, + + /* U+0054 "T" */ + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x63, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x3f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x60, 0x22, 0x22, 0x22, 0x22, 0x5f, + 0xff, 0x72, 0x22, 0x22, 0x22, 0x21, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0055 "U" */ + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf6, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf6, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf6, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf6, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf6, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf6, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf6, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf6, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf6, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf6, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, + 0xef, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf6, 0xdf, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf5, 0xcf, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf3, 0x9f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf1, 0x5f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0xf, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0x80, 0x9, 0xff, 0xfd, 0x30, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x20, 0x1, 0xef, 0xff, + 0xfb, 0x65, 0x34, 0x69, 0xef, 0xff, 0xf7, 0x0, + 0x0, 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x2, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd4, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x7b, 0xde, 0xff, 0xec, 0x94, 0x0, 0x0, + 0x0, + + /* U+0056 "V" */ + 0x9f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xd0, 0x3f, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0x70, 0xd, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x10, 0x7, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xfa, 0x0, 0x1, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf4, + 0x0, 0x0, 0xaf, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xe0, 0x0, 0x0, 0x4f, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x70, 0x0, 0x0, 0xe, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x10, 0x0, + 0x0, 0x8, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xfb, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x30, 0x0, 0x0, 0x0, 0xe, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0xaf, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf4, 0x0, 0x0, 0x1, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfa, + 0x0, 0x0, 0x6, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x0, 0x0, 0xc, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0x60, 0x0, 0x2f, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xb0, + 0x0, 0x8f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf1, 0x0, 0xef, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xf7, 0x3, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfc, 0x9, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x2e, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0057 "W" */ + 0x7f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf3, 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xe0, 0xe, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xa0, 0xa, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfd, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x60, + 0x6, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xf8, 0xdf, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0x10, 0x2, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xf4, 0x8f, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xfd, 0x0, 0x0, 0xdf, 0xf9, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xf0, 0x4f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf9, 0x0, 0x0, 0x9f, + 0xfd, 0x0, 0x0, 0x0, 0x5, 0xff, 0xb0, 0xf, + 0xff, 0x40, 0x0, 0x0, 0x1, 0xff, 0xf4, 0x0, + 0x0, 0x5f, 0xff, 0x10, 0x0, 0x0, 0xa, 0xff, + 0x70, 0xb, 0xff, 0x80, 0x0, 0x0, 0x5, 0xff, + 0xf0, 0x0, 0x0, 0x1f, 0xff, 0x40, 0x0, 0x0, + 0xe, 0xff, 0x30, 0x7, 0xff, 0xd0, 0x0, 0x0, + 0x9, 0xff, 0xb0, 0x0, 0x0, 0xc, 0xff, 0x80, + 0x0, 0x0, 0x3f, 0xfe, 0x0, 0x2, 0xff, 0xf1, + 0x0, 0x0, 0xd, 0xff, 0x70, 0x0, 0x0, 0x8, + 0xff, 0xc0, 0x0, 0x0, 0x7f, 0xfa, 0x0, 0x0, + 0xef, 0xf6, 0x0, 0x0, 0x1f, 0xff, 0x20, 0x0, + 0x0, 0x4, 0xff, 0xf0, 0x0, 0x0, 0xcf, 0xf5, + 0x0, 0x0, 0x9f, 0xfa, 0x0, 0x0, 0x5f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf3, 0x0, 0x1, + 0xff, 0xf1, 0x0, 0x0, 0x5f, 0xff, 0x0, 0x0, + 0x9f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf7, + 0x0, 0x5, 0xff, 0xc0, 0x0, 0x0, 0x1f, 0xff, + 0x30, 0x0, 0xdf, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfb, 0x0, 0xa, 0xff, 0x80, 0x0, 0x0, + 0xc, 0xff, 0x70, 0x1, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xfe, 0x0, 0xe, 0xff, 0x30, + 0x0, 0x0, 0x7, 0xff, 0xb0, 0x4, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0x20, 0x3f, + 0xfe, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf0, 0x8, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0x60, 0x7f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xf3, 0xc, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0x90, 0xbf, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xf6, 0xf, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xd0, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xf9, 0x4f, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf4, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xfc, 0x8f, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xfa, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xbf, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x0, 0x0, 0x0, 0x0, + + /* U+0058 "X" */ + 0x3, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xdf, 0xfe, 0x10, 0x0, 0x8f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf3, 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0x70, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x50, 0x0, 0x8, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xe1, 0x0, 0x4f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xfb, 0x1, 0xef, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x6b, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xef, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0x1c, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf5, 0x2, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xa0, + 0x0, 0x6f, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xfd, 0x0, 0x0, 0xa, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xf3, 0x0, 0x0, 0x1, 0xef, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x90, 0x0, + 0x1, 0xef, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf4, 0x0, 0xb, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xfe, 0x10, 0x7f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xb0, + + /* U+0059 "Y" */ + 0x8f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xb0, 0xd, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xfe, 0x10, 0x3, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf4, 0x0, 0x0, + 0x8f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x90, 0x0, 0x0, 0xd, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf7, + 0x0, 0x0, 0x2, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x20, 0x0, 0xc, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xb0, 0x0, 0x6f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf5, + 0x1, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xfe, 0xa, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xbf, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+005A "Z" */ + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x0, 0xb, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x0, 0x2, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x22, 0x23, 0xef, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfd, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x53, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x30, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x35, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, + + /* U+005B "[" */ + 0x7f, 0xff, 0xff, 0xfe, 0x7f, 0xff, 0xff, 0xfe, + 0x7f, 0xff, 0xbb, 0xba, 0x7f, 0xfd, 0x0, 0x0, + 0x7f, 0xfd, 0x0, 0x0, 0x7f, 0xfd, 0x0, 0x0, + 0x7f, 0xfd, 0x0, 0x0, 0x7f, 0xfd, 0x0, 0x0, + 0x7f, 0xfd, 0x0, 0x0, 0x7f, 0xfd, 0x0, 0x0, + 0x7f, 0xfd, 0x0, 0x0, 0x7f, 0xfd, 0x0, 0x0, + 0x7f, 0xfd, 0x0, 0x0, 0x7f, 0xfd, 0x0, 0x0, + 0x7f, 0xfd, 0x0, 0x0, 0x7f, 0xfd, 0x0, 0x0, + 0x7f, 0xfd, 0x0, 0x0, 0x7f, 0xfd, 0x0, 0x0, + 0x7f, 0xfd, 0x0, 0x0, 0x7f, 0xfd, 0x0, 0x0, + 0x7f, 0xfd, 0x0, 0x0, 0x7f, 0xfd, 0x0, 0x0, + 0x7f, 0xfd, 0x0, 0x0, 0x7f, 0xfd, 0x0, 0x0, + 0x7f, 0xfd, 0x0, 0x0, 0x7f, 0xfd, 0x0, 0x0, + 0x7f, 0xfd, 0x0, 0x0, 0x7f, 0xfd, 0x0, 0x0, + 0x7f, 0xfd, 0x0, 0x0, 0x7f, 0xfd, 0x0, 0x0, + 0x7f, 0xfd, 0x0, 0x0, 0x7f, 0xff, 0xcc, 0xca, + 0x7f, 0xff, 0xff, 0xfe, 0x7f, 0xff, 0xff, 0xfe, + + /* U+005C "\\" */ + 0xdf, 0xd0, 0x0, 0x0, 0x0, 0x9, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x4f, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xb0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf4, 0x0, 0x0, + 0x0, 0x1, 0xff, 0x90, 0x0, 0x0, 0x0, 0xc, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf2, 0x0, + 0x0, 0x0, 0x3, 0xff, 0x70, 0x0, 0x0, 0x0, + 0xe, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x1f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xe0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x2f, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xc0, 0x0, 0x0, 0x0, 0x9, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x4f, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf3, 0x0, 0x0, + 0x0, 0x2, 0xff, 0x80, 0x0, 0x0, 0x0, 0xd, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf1, 0x0, + 0x0, 0x0, 0x4, 0xff, 0x60, + + /* U+005D "]" */ + 0x5f, 0xff, 0xff, 0xff, 0x5, 0xff, 0xff, 0xff, + 0xf0, 0x3b, 0xbb, 0xdf, 0xff, 0x0, 0x0, 0x5, + 0xff, 0xf0, 0x0, 0x0, 0x5f, 0xff, 0x0, 0x0, + 0x5, 0xff, 0xf0, 0x0, 0x0, 0x5f, 0xff, 0x0, + 0x0, 0x5, 0xff, 0xf0, 0x0, 0x0, 0x5f, 0xff, + 0x0, 0x0, 0x5, 0xff, 0xf0, 0x0, 0x0, 0x5f, + 0xff, 0x0, 0x0, 0x5, 0xff, 0xf0, 0x0, 0x0, + 0x5f, 0xff, 0x0, 0x0, 0x5, 0xff, 0xf0, 0x0, + 0x0, 0x5f, 0xff, 0x0, 0x0, 0x5, 0xff, 0xf0, + 0x0, 0x0, 0x5f, 0xff, 0x0, 0x0, 0x5, 0xff, + 0xf0, 0x0, 0x0, 0x5f, 0xff, 0x0, 0x0, 0x5, + 0xff, 0xf0, 0x0, 0x0, 0x5f, 0xff, 0x0, 0x0, + 0x5, 0xff, 0xf0, 0x0, 0x0, 0x5f, 0xff, 0x0, + 0x0, 0x5, 0xff, 0xf0, 0x0, 0x0, 0x5f, 0xff, + 0x0, 0x0, 0x5, 0xff, 0xf0, 0x0, 0x0, 0x5f, + 0xff, 0x0, 0x0, 0x5, 0xff, 0xf0, 0x0, 0x0, + 0x5f, 0xff, 0x0, 0x0, 0x5, 0xff, 0xf0, 0x0, + 0x0, 0x5f, 0xff, 0x3, 0xcc, 0xcd, 0xff, 0xf0, + 0x5f, 0xff, 0xff, 0xff, 0x5, 0xff, 0xff, 0xff, + 0xf0, + + /* U+005E "^" */ + 0x0, 0x0, 0x0, 0xaf, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xf9, 0xdf, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf3, 0x6f, 0xfa, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xd0, 0xf, 0xff, 0x10, 0x0, + 0x0, 0xb, 0xff, 0x60, 0x9, 0xff, 0x80, 0x0, + 0x0, 0x2f, 0xff, 0x10, 0x3, 0xff, 0xe0, 0x0, + 0x0, 0x9f, 0xfa, 0x0, 0x0, 0xcf, 0xf6, 0x0, + 0x1, 0xff, 0xf3, 0x0, 0x0, 0x6f, 0xfd, 0x0, + 0x7, 0xff, 0xd0, 0x0, 0x0, 0xe, 0xff, 0x40, + 0xe, 0xff, 0x60, 0x0, 0x0, 0x8, 0xff, 0xb0, + 0x5f, 0xff, 0x10, 0x0, 0x0, 0x2, 0xff, 0xf2, + 0xcf, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf9, + + /* U+005F "_" */ + 0x16, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, + 0x66, 0x66, 0x66, 0x23, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x3f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x50, + + /* U+0060 "`" */ + 0x2, 0x22, 0x20, 0x0, 0xc, 0xff, 0xf7, 0x0, + 0x1, 0xef, 0xfe, 0x0, 0x0, 0x2f, 0xff, 0x60, + 0x0, 0x5, 0xff, 0xe0, 0x0, 0x0, 0x7f, 0xf6, + + /* U+0061 "a" */ + 0x0, 0x0, 0x5, 0xad, 0xef, 0xfe, 0xc8, 0x20, + 0x0, 0x0, 0x0, 0x4e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x6f, 0xff, 0xfe, 0xcc, + 0xcf, 0xff, 0xff, 0xa0, 0x0, 0x2f, 0xff, 0xd4, + 0x0, 0x0, 0x5, 0xef, 0xff, 0x10, 0x9, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf5, 0x0, + 0xdf, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0x70, 0x0, 0x24, 0x10, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x5e, 0xff, 0x80, 0x0, 0x0, 0x0, 0x25, + 0x79, 0xbe, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x3a, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, + 0xaf, 0xff, 0xff, 0xff, 0xeb, 0x73, 0xdf, 0xf8, + 0x0, 0xaf, 0xff, 0xfa, 0x63, 0x10, 0x0, 0xd, + 0xff, 0x80, 0x2f, 0xff, 0xc1, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf8, 0x7, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x80, 0x8f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xf8, 0x7, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x90, + 0x2f, 0xff, 0xd3, 0x0, 0x0, 0x17, 0xff, 0xff, + 0xf9, 0x0, 0xaf, 0xff, 0xfc, 0xaa, 0xcf, 0xff, + 0xfd, 0xff, 0xb0, 0x0, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xd3, 0x6f, 0xff, 0x0, 0x0, 0x4a, 0xdf, + 0xfe, 0xc9, 0x40, 0x1, 0xff, 0xf5, + + /* U+0062 "b" */ + 0x7f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xfe, 0x0, 0x6c, 0xef, 0xeb, 0x50, 0x0, 0x0, + 0x7f, 0xfe, 0x1d, 0xff, 0xff, 0xff, 0xfd, 0x20, + 0x0, 0x7f, 0xff, 0xdf, 0xff, 0xcc, 0xff, 0xff, + 0xe3, 0x0, 0x7f, 0xff, 0xff, 0x70, 0x0, 0x6, + 0xff, 0xfd, 0x0, 0x7f, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x80, 0x7f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xe0, 0x7f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf3, 0x7f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf7, 0x7f, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf9, + 0x7f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xfa, 0x7f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xf9, 0x7f, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xf8, 0x7f, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf6, 0x7f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xf2, 0x7f, 0xff, 0x70, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xd0, 0x7f, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x60, 0x7f, + 0xff, 0xfe, 0x60, 0x0, 0x8, 0xff, 0xfb, 0x0, + 0x7f, 0xfc, 0xef, 0xfe, 0xcc, 0xff, 0xff, 0xd1, + 0x0, 0x7f, 0xfa, 0x2d, 0xff, 0xff, 0xff, 0xfa, + 0x10, 0x0, 0x7f, 0xfa, 0x0, 0x7c, 0xff, 0xd9, + 0x30, 0x0, 0x0, + + /* U+0063 "c" */ + 0x0, 0x0, 0x3, 0x8c, 0xef, 0xec, 0x81, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xdc, 0xdf, + 0xff, 0xfa, 0x0, 0x0, 0xbf, 0xff, 0xa1, 0x0, + 0x2, 0xbf, 0xff, 0x60, 0x5, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xd0, 0xc, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf2, 0x1f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x85, 0x30, 0x4f, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x45, 0x30, 0x1f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf8, 0xc, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf4, 0x5, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0xb, 0xff, 0xd0, + 0x0, 0xbf, 0xff, 0x70, 0x0, 0x1, 0xbf, 0xff, + 0x50, 0x0, 0x1d, 0xff, 0xff, 0xcb, 0xdf, 0xff, + 0xf8, 0x0, 0x0, 0x1, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x3, 0x8c, 0xef, + 0xec, 0x71, 0x0, 0x0, + + /* U+0064 "d" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf7, 0x0, + 0x0, 0x5, 0xbe, 0xfe, 0xc6, 0x0, 0xdf, 0xf7, + 0x0, 0x2, 0xdf, 0xff, 0xff, 0xff, 0xd2, 0xdf, + 0xf7, 0x0, 0x3e, 0xff, 0xff, 0xcc, 0xff, 0xfd, + 0xef, 0xf7, 0x0, 0xdf, 0xff, 0x70, 0x0, 0x6, + 0xff, 0xff, 0xf7, 0x7, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf7, 0xe, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf7, 0x3f, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf7, 0x6f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf7, 0x8f, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf7, + 0x9f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xf7, 0x9f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf7, 0x8f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xf7, 0x6f, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xf7, 0x2f, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xf7, 0xd, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf7, 0x6, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf7, 0x0, + 0xbf, 0xff, 0x80, 0x0, 0x5, 0xef, 0xff, 0xf7, + 0x0, 0x1d, 0xff, 0xff, 0xcc, 0xef, 0xfe, 0xcf, + 0xf7, 0x0, 0x1, 0xbf, 0xff, 0xff, 0xff, 0xe3, + 0xaf, 0xf7, 0x0, 0x0, 0x4, 0xad, 0xfe, 0xc7, + 0x10, 0xaf, 0xf7, + + /* U+0065 "e" */ + 0x0, 0x0, 0x2, 0x7c, 0xef, 0xed, 0x93, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0x10, 0x0, 0x0, 0xb, 0xff, 0xff, 0xdc, + 0xcf, 0xff, 0xfd, 0x10, 0x0, 0x9, 0xff, 0xfa, + 0x20, 0x0, 0x7, 0xff, 0xfc, 0x0, 0x3, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, 0x0, + 0xaf, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xd0, 0xf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x24, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf6, 0x6f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x87, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x8f, + 0xff, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, + 0x77, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x97, 0x52, 0xc, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x40, 0x5f, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xd0, + 0x0, 0xbf, 0xff, 0xc3, 0x0, 0x0, 0x6e, 0xff, + 0xf4, 0x0, 0x1, 0xcf, 0xff, 0xfe, 0xcc, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xe5, 0x0, 0x0, 0x0, 0x0, 0x28, + 0xce, 0xff, 0xeb, 0x60, 0x0, 0x0, + + /* U+0066 "f" */ + 0x0, 0x0, 0x5, 0xbe, 0xff, 0xd8, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xf9, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x9, 0xff, 0xf6, 0x21, 0x21, + 0x0, 0xb, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0x90, 0x0, 0x0, 0x0, 0xc, 0xff, 0x90, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, 0x60, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0x60, 0x69, 0x9e, + 0xff, 0xd9, 0x99, 0x30, 0x0, 0xc, 0xff, 0x90, + 0x0, 0x0, 0x0, 0xc, 0xff, 0x90, 0x0, 0x0, + 0x0, 0xc, 0xff, 0x90, 0x0, 0x0, 0x0, 0xc, + 0xff, 0x90, 0x0, 0x0, 0x0, 0xc, 0xff, 0x90, + 0x0, 0x0, 0x0, 0xc, 0xff, 0x90, 0x0, 0x0, + 0x0, 0xc, 0xff, 0x90, 0x0, 0x0, 0x0, 0xc, + 0xff, 0x90, 0x0, 0x0, 0x0, 0xc, 0xff, 0x90, + 0x0, 0x0, 0x0, 0xc, 0xff, 0x90, 0x0, 0x0, + 0x0, 0xc, 0xff, 0x90, 0x0, 0x0, 0x0, 0xc, + 0xff, 0x90, 0x0, 0x0, 0x0, 0xc, 0xff, 0x90, + 0x0, 0x0, 0x0, 0xc, 0xff, 0x90, 0x0, 0x0, + 0x0, 0xc, 0xff, 0x90, 0x0, 0x0, 0x0, 0xc, + 0xff, 0x90, 0x0, 0x0, 0x0, 0xc, 0xff, 0x90, + 0x0, 0x0, + + /* U+0067 "g" */ + 0x0, 0x0, 0x5, 0xad, 0xfe, 0xc7, 0x10, 0x6f, + 0xfa, 0x0, 0x2, 0xcf, 0xff, 0xff, 0xff, 0xe4, + 0x6f, 0xfa, 0x0, 0x2e, 0xff, 0xff, 0xdc, 0xff, + 0xff, 0xbf, 0xfa, 0x0, 0xdf, 0xff, 0x70, 0x0, + 0x5, 0xef, 0xff, 0xfa, 0x7, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xfa, 0xe, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xfa, 0x3f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfa, 0x7f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfa, + 0x9f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xfa, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfa, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xfa, 0x9f, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xfa, 0x7f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xfa, 0x3f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xfa, 0xe, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfa, 0x7, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x2e, 0xff, 0xfa, + 0x0, 0xdf, 0xff, 0x80, 0x0, 0x5, 0xef, 0xff, + 0xfa, 0x0, 0x2e, 0xff, 0xff, 0xcc, 0xef, 0xff, + 0xef, 0xfa, 0x0, 0x2, 0xcf, 0xff, 0xff, 0xff, + 0xe3, 0xcf, 0xf9, 0x0, 0x0, 0x5, 0xae, 0xff, + 0xc7, 0x0, 0xcf, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xf6, 0x9, 0x75, 0x10, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xf3, 0xe, 0xff, + 0x80, 0x0, 0x0, 0x0, 0xa, 0xff, 0xe0, 0x9, + 0xff, 0xf7, 0x0, 0x0, 0x3, 0xbf, 0xff, 0x60, + 0x1, 0xef, 0xff, 0xfd, 0xcd, 0xef, 0xff, 0xf9, + 0x0, 0x0, 0x2d, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x5a, 0xde, 0xff, 0xeb, + 0x60, 0x0, 0x0, + + /* U+0068 "h" */ + 0x7f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xe0, 0x4, 0xad, + 0xff, 0xd9, 0x30, 0x0, 0x7f, 0xfe, 0x1b, 0xff, + 0xff, 0xff, 0xff, 0x80, 0x7, 0xff, 0xfd, 0xff, + 0xfe, 0xef, 0xff, 0xff, 0x60, 0x7f, 0xff, 0xff, + 0x92, 0x0, 0x7, 0xff, 0xfe, 0x7, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x7, 0xff, 0xf4, 0x7f, 0xff, + 0x90, 0x0, 0x0, 0x0, 0xf, 0xff, 0x77, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf8, 0x7f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0x97, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf9, + 0x7f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0x97, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xf9, 0x7f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0x97, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf9, 0x7f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0x97, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xf9, 0x7f, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0x97, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xf9, 0x7f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0x97, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xf9, 0x7f, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0x90, + + /* U+0069 "i" */ + 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, 0x5d, 0xdb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfe, + 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, + 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, + 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, + 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, + 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, + + /* U+006A "j" */ + 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x7f, 0xfe, + 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x5d, 0xdc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfe, + 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x7f, 0xfe, + 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x7f, 0xfe, + 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x7f, 0xfe, + 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x7f, 0xfe, + 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x7f, 0xfe, + 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x7f, 0xfe, + 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x7f, 0xfe, + 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x7f, 0xfe, + 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x7f, 0xfe, + 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x7f, 0xfe, + 0x0, 0x0, 0x7f, 0xfd, 0x0, 0x0, 0x9f, 0xfb, + 0x0, 0x2, 0xef, 0xf9, 0x3f, 0xff, 0xff, 0xf4, + 0x6f, 0xff, 0xff, 0xb0, 0x6e, 0xff, 0xd7, 0x0, + + /* U+006B "k" */ + 0x7f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x90, 0x7f, 0xfd, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0x90, 0x7, 0xff, 0xd0, 0x0, + 0x0, 0xaf, 0xff, 0x80, 0x0, 0x7f, 0xfd, 0x0, + 0x0, 0xaf, 0xff, 0x80, 0x0, 0x7, 0xff, 0xd0, + 0x0, 0x9f, 0xff, 0x80, 0x0, 0x0, 0x7f, 0xfd, + 0x0, 0x9f, 0xff, 0x80, 0x0, 0x0, 0x7, 0xff, + 0xd0, 0x8f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x7f, + 0xfd, 0x8f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0x75, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x70, 0xa, 0xff, 0xf4, 0x0, + 0x0, 0x7, 0xff, 0xd0, 0x0, 0x1f, 0xff, 0xd0, + 0x0, 0x0, 0x7f, 0xfd, 0x0, 0x0, 0x6f, 0xff, + 0x90, 0x0, 0x7, 0xff, 0xd0, 0x0, 0x0, 0xcf, + 0xff, 0x30, 0x0, 0x7f, 0xfd, 0x0, 0x0, 0x2, + 0xff, 0xfd, 0x0, 0x7, 0xff, 0xd0, 0x0, 0x0, + 0x7, 0xff, 0xf8, 0x0, 0x7f, 0xfd, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf3, 0x7, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xd0, 0x7f, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0x80, + + /* U+006C "l" */ + 0x8f, 0xfd, 0x8f, 0xfd, 0x8f, 0xfd, 0x8f, 0xfd, + 0x8f, 0xfd, 0x8f, 0xfd, 0x8f, 0xfd, 0x8f, 0xfd, + 0x8f, 0xfd, 0x8f, 0xfd, 0x8f, 0xfd, 0x8f, 0xfd, + 0x8f, 0xfd, 0x8f, 0xfd, 0x8f, 0xfd, 0x8f, 0xfd, + 0x8f, 0xfd, 0x8f, 0xfd, 0x8f, 0xfd, 0x8f, 0xfd, + 0x8f, 0xfd, 0x8f, 0xfd, 0x8f, 0xfd, 0x8f, 0xfd, + 0x8f, 0xfd, 0x8f, 0xfd, 0x8f, 0xfd, + + /* U+006D "m" */ + 0x8f, 0xf7, 0x0, 0x5b, 0xef, 0xeb, 0x50, 0x0, + 0x1, 0x7c, 0xef, 0xda, 0x30, 0x0, 0x8f, 0xf7, + 0x2c, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x4e, 0xff, + 0xff, 0xff, 0xf7, 0x0, 0x8f, 0xf8, 0xdf, 0xff, + 0xef, 0xff, 0xff, 0x83, 0xff, 0xff, 0xef, 0xff, + 0xff, 0x40, 0x8f, 0xff, 0xfe, 0x60, 0x0, 0x5f, + 0xff, 0xfe, 0xfc, 0x30, 0x0, 0x7f, 0xff, 0xb0, + 0x8f, 0xff, 0xe2, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0xb, 0xff, 0xf0, 0x8f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x5, 0xff, 0xf1, 0x8f, 0xff, 0x20, 0x0, + 0x0, 0x0, 0xdf, 0xfc, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf2, 0x8f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xf9, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf3, + 0x8f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf8, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf3, 0x8f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf8, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xf3, 0x8f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf8, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf3, 0x8f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xf8, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf3, + 0x8f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf8, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf3, 0x8f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf8, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xf3, 0x8f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf8, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf3, 0x8f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xf8, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf3, + 0x8f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf8, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf3, 0x8f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf8, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xf3, 0x8f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf8, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf3, 0x8f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xf8, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf3, + + /* U+006E "n" */ + 0x6f, 0xf9, 0x0, 0x4a, 0xdf, 0xfd, 0x92, 0x0, + 0x6, 0xff, 0x91, 0xaf, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x6f, 0xf9, 0xcf, 0xff, 0xee, 0xff, 0xff, + 0xf7, 0x6, 0xff, 0xff, 0xf8, 0x10, 0x1, 0x7f, + 0xff, 0xf0, 0x6f, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0x46, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xf7, 0x6f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0xd, 0xff, 0x86, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xf9, 0x6f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0x96, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xf9, 0x6f, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0x96, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf9, 0x6f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x96, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf9, 0x6f, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x96, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf9, + 0x6f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0x96, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xf9, 0x6f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0x96, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xf9, + + /* U+006F "o" */ + 0x0, 0x0, 0x2, 0x8c, 0xef, 0xed, 0x93, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, + 0xfb, 0x10, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xdc, + 0xdf, 0xff, 0xfe, 0x20, 0x0, 0xd, 0xff, 0xfa, + 0x20, 0x0, 0x19, 0xff, 0xfd, 0x0, 0x7, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf9, 0x0, + 0xef, 0xfc, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf1, 0x3f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x57, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xf9, 0x8f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xb9, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfc, 0xaf, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xb8, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xfa, 0x7f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0x83, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf5, 0xe, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x10, 0x7f, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x90, + 0x0, 0xdf, 0xff, 0xa1, 0x0, 0x1, 0x8f, 0xff, + 0xe1, 0x0, 0x2, 0xdf, 0xff, 0xfd, 0xbc, 0xff, + 0xff, 0xe3, 0x0, 0x0, 0x1, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xb1, 0x0, 0x0, 0x0, 0x0, 0x28, + 0xce, 0xfe, 0xd9, 0x30, 0x0, 0x0, + + /* U+0070 "p" */ + 0x6f, 0xfa, 0x0, 0x6c, 0xef, 0xeb, 0x60, 0x0, + 0x0, 0x6f, 0xfa, 0x2d, 0xff, 0xff, 0xff, 0xfd, + 0x30, 0x0, 0x6f, 0xfb, 0xdf, 0xfe, 0xaa, 0xdf, + 0xff, 0xf3, 0x0, 0x6f, 0xff, 0xff, 0x60, 0x0, + 0x5, 0xff, 0xfe, 0x0, 0x6f, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0x80, 0x6f, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xe0, 0x6f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf4, 0x6f, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf7, + 0x6f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xf9, 0x6f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xfa, 0x6f, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xfa, 0x6f, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf8, 0x6f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xf6, 0x6f, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf2, 0x6f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0xb, 0xff, 0xd0, 0x6f, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x60, + 0x6f, 0xff, 0xfe, 0x40, 0x0, 0x8, 0xff, 0xfc, + 0x0, 0x6f, 0xff, 0xef, 0xfe, 0xcc, 0xff, 0xff, + 0xd1, 0x0, 0x6f, 0xfe, 0x3e, 0xff, 0xff, 0xff, + 0xfb, 0x10, 0x0, 0x6f, 0xfe, 0x0, 0x7c, 0xff, + 0xda, 0x40, 0x0, 0x0, 0x6f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+0071 "q" */ + 0x0, 0x0, 0x5, 0xbe, 0xfe, 0xc6, 0x0, 0x8f, + 0xf7, 0x0, 0x2, 0xdf, 0xff, 0xff, 0xff, 0xd2, + 0x8f, 0xf7, 0x0, 0x2e, 0xff, 0xfe, 0xaa, 0xdf, + 0xfe, 0xaf, 0xf7, 0x0, 0xdf, 0xff, 0x50, 0x0, + 0x5, 0xef, 0xff, 0xf7, 0x7, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf7, 0xe, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf7, 0x2f, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf7, 0x6f, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf7, + 0x8f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xf7, 0x9f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf7, 0x8f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xf7, 0x7f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf7, 0x5f, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xf7, 0x1f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf7, 0xb, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf7, 0x4, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x2e, 0xff, 0xf7, + 0x0, 0xaf, 0xff, 0x91, 0x0, 0x5, 0xef, 0xff, + 0xf7, 0x0, 0xc, 0xff, 0xff, 0xcb, 0xef, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, + 0xe3, 0xdf, 0xf7, 0x0, 0x0, 0x3, 0x9d, 0xff, + 0xc7, 0x0, 0xdf, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xf7, + + /* U+0072 "r" */ + 0x8f, 0xf7, 0x2, 0xbf, 0xec, 0x70, 0x8f, 0xf7, + 0x3f, 0xff, 0xff, 0xe0, 0x8f, 0xf8, 0xef, 0xff, + 0xff, 0x90, 0x8f, 0xff, 0xff, 0xa7, 0x9e, 0x30, + 0x8f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xfd, 0x0, 0x0, 0x0, 0x0, + + /* U+0073 "s" */ + 0x0, 0x0, 0x6b, 0xef, 0xfe, 0xc8, 0x20, 0x0, + 0x0, 0x4, 0xef, 0xff, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x4, 0xff, 0xff, 0xec, 0xce, 0xff, 0xff, + 0xa0, 0x0, 0xdf, 0xfc, 0x30, 0x0, 0x3, 0xcf, + 0xff, 0x30, 0x2f, 0xff, 0x10, 0x0, 0x0, 0x1, + 0xef, 0xf9, 0x4, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x7, 0xb9, 0x50, 0x2f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xe9, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0xfc, 0x72, 0x0, 0x0, 0x0, 0x3, 0xcf, 0xff, + 0xff, 0xff, 0xfd, 0x70, 0x0, 0x0, 0x0, 0x38, + 0xdf, 0xff, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, + 0x0, 0x15, 0xae, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xdf, 0xff, 0x43, 0x58, + 0x50, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf7, 0xaf, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0x75, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf4, + 0xd, 0xff, 0xf7, 0x0, 0x0, 0x5, 0xef, 0xfd, + 0x0, 0x3f, 0xff, 0xff, 0xdb, 0xce, 0xff, 0xff, + 0x30, 0x0, 0x3d, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x30, 0x0, 0x0, 0x5, 0xad, 0xff, 0xfd, 0xa5, + 0x0, 0x0, + + /* U+0074 "t" */ + 0x0, 0x0, 0x4, 0x40, 0x0, 0x0, 0x0, 0x2b, + 0xf6, 0x0, 0x0, 0x0, 0xe, 0xff, 0x60, 0x0, + 0x0, 0x0, 0xff, 0xf6, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x60, 0x0, 0x0, 0x0, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0xf, 0xff, 0x60, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xff, 0xb0, 0x6f, 0xff, 0xff, 0xff, + 0xfb, 0x3, 0x99, 0xff, 0xfb, 0x99, 0x60, 0x0, + 0xf, 0xff, 0x60, 0x0, 0x0, 0x0, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x60, 0x0, 0x0, + 0x0, 0xff, 0xf6, 0x0, 0x0, 0x0, 0xf, 0xff, + 0x60, 0x0, 0x0, 0x0, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0xf, 0xff, 0x60, 0x0, 0x0, 0x0, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0xf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0xff, 0xf6, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x60, 0x0, 0x0, 0x0, 0xef, 0xf6, 0x0, + 0x0, 0x0, 0xe, 0xff, 0x80, 0x0, 0x0, 0x0, + 0xdf, 0xfd, 0x31, 0x20, 0x0, 0xa, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x2a, 0xef, 0xfd, 0x10, + + /* U+0075 "u" */ + 0x8f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0x78, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xf7, 0x8f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0x78, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xf7, 0x8f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x78, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xf7, 0x8f, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0x78, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf7, 0x8f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0x78, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf7, 0x8f, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0x78, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xf7, 0x7f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x77, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf7, 0x5f, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x73, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf7, + 0xe, 0xff, 0xf9, 0x10, 0x1, 0x7f, 0xff, 0xff, + 0x70, 0x5f, 0xff, 0xff, 0xee, 0xff, 0xfc, 0x8f, + 0xf7, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xfa, 0x8, + 0xff, 0x70, 0x0, 0x28, 0xdf, 0xfd, 0xa4, 0x0, + 0x8f, 0xf7, + + /* U+0076 "v" */ + 0x5f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x50, 0xef, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xf0, 0x9, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xfa, 0x0, 0x3f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x40, 0x0, 0xdf, + 0xf9, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd0, 0x0, + 0x7, 0xff, 0xe0, 0x0, 0x0, 0x0, 0xdf, 0xf8, + 0x0, 0x0, 0x1f, 0xff, 0x40, 0x0, 0x0, 0x3f, + 0xff, 0x20, 0x0, 0x0, 0xbf, 0xfa, 0x0, 0x0, + 0x9, 0xff, 0xc0, 0x0, 0x0, 0x5, 0xff, 0xf0, + 0x0, 0x0, 0xef, 0xf6, 0x0, 0x0, 0x0, 0xe, + 0xff, 0x50, 0x0, 0x4f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xfb, 0x0, 0xa, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf1, 0x0, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0x60, 0x5f, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfb, + 0xb, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xf1, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xbf, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x40, 0x0, 0x0, 0x0, + + /* U+0077 "w" */ + 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf1, 0x5f, 0xff, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xc0, 0x1f, 0xff, 0x50, 0x0, + 0x0, 0x9, 0xff, 0xff, 0x20, 0x0, 0x0, 0xc, + 0xff, 0x70, 0xc, 0xff, 0x90, 0x0, 0x0, 0xd, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x1f, 0xff, 0x20, + 0x7, 0xff, 0xd0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x5f, 0xfd, 0x0, 0x2, 0xff, + 0xf2, 0x0, 0x0, 0x6f, 0xf9, 0xff, 0xe0, 0x0, + 0x0, 0xaf, 0xf8, 0x0, 0x0, 0xdf, 0xf6, 0x0, + 0x0, 0xaf, 0xf3, 0xef, 0xf2, 0x0, 0x0, 0xef, + 0xf3, 0x0, 0x0, 0x8f, 0xfa, 0x0, 0x0, 0xef, + 0xe0, 0xaf, 0xf7, 0x0, 0x3, 0xff, 0xe0, 0x0, + 0x0, 0x4f, 0xfe, 0x0, 0x2, 0xff, 0xa0, 0x6f, + 0xfb, 0x0, 0x8, 0xff, 0x90, 0x0, 0x0, 0xe, + 0xff, 0x30, 0x7, 0xff, 0x60, 0x2f, 0xff, 0x0, + 0xc, 0xff, 0x40, 0x0, 0x0, 0xa, 0xff, 0x70, + 0xb, 0xff, 0x20, 0xe, 0xff, 0x30, 0x1f, 0xff, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xc0, 0xf, 0xfe, + 0x0, 0xa, 0xff, 0x70, 0x6f, 0xfa, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xf0, 0x3f, 0xfa, 0x0, 0x6, + 0xff, 0xb0, 0xaf, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf4, 0x7f, 0xf6, 0x0, 0x1, 0xff, 0xf0, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, + 0xbf, 0xf2, 0x0, 0x0, 0xdf, 0xf7, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xfd, 0xff, 0xd0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0x50, 0x0, 0x0, 0x1f, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0x10, 0x0, 0x0, 0xc, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfd, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xf3, 0x0, 0x0, 0x0, + + /* U+0078 "x" */ + 0xd, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xfc, 0x0, 0x2f, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x20, 0x0, 0x7f, 0xff, 0x90, 0x0, + 0x0, 0x8f, 0xff, 0x60, 0x0, 0x0, 0xcf, 0xff, + 0x40, 0x0, 0x4f, 0xff, 0xa0, 0x0, 0x0, 0x1, + 0xff, 0xfd, 0x0, 0x1e, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf8, 0xa, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf7, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf7, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf9, + 0x9, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xfe, 0x0, 0xe, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0x40, 0x0, 0x4f, 0xff, 0x90, 0x0, + 0x0, 0x4f, 0xff, 0x90, 0x0, 0x0, 0xaf, 0xff, + 0x40, 0x0, 0x1e, 0xff, 0xe1, 0x0, 0x0, 0x1, + 0xef, 0xfe, 0x10, 0xa, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xfa, 0x5, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xf5, + + /* U+0079 "y" */ + 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0x70, 0xcf, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf1, 0x6, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xfb, 0x0, 0x1f, 0xff, 0x80, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x50, 0x0, 0xaf, + 0xfd, 0x0, 0x0, 0x0, 0x5, 0xff, 0xe0, 0x0, + 0x4, 0xff, 0xf3, 0x0, 0x0, 0x0, 0xcf, 0xf8, + 0x0, 0x0, 0xd, 0xff, 0x90, 0x0, 0x0, 0x2f, + 0xff, 0x20, 0x0, 0x0, 0x7f, 0xff, 0x0, 0x0, + 0x8, 0xff, 0xc0, 0x0, 0x0, 0x1, 0xff, 0xf5, + 0x0, 0x0, 0xef, 0xf6, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xb0, 0x0, 0x4f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x10, 0xa, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xf7, 0x0, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xc0, 0x5f, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x1a, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf6, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xef, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0x44, 0x8f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7e, 0xfe, 0xa2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+007A "z" */ + 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x90, 0x5, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaf, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xbc, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xd2, 0x4f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x34, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, + + /* U+007B "{" */ + 0x0, 0x0, 0x0, 0x6c, 0xef, 0xd0, 0x0, 0x0, + 0xbf, 0xff, 0xfd, 0x0, 0x0, 0x6f, 0xff, 0xfe, + 0xb0, 0x0, 0xb, 0xff, 0xb1, 0x0, 0x0, 0x0, + 0xef, 0xf3, 0x0, 0x0, 0x0, 0xf, 0xff, 0x10, + 0x0, 0x0, 0x0, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x4f, 0xfe, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0xdf, 0xf6, 0x0, 0x0, 0x14, 0xcf, 0xfd, + 0x0, 0x0, 0xe, 0xff, 0xfb, 0x10, 0x0, 0x0, + 0xef, 0xf9, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x3, 0xcf, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xf4, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x5f, 0xfd, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0x10, 0x0, 0x0, 0x0, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0xe, 0xff, 0x40, 0x0, 0x0, 0x0, 0xbf, + 0xfc, 0x10, 0x0, 0x0, 0x5, 0xff, 0xff, 0xeb, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x7, 0xce, 0xfd, + + /* U+007C "|" */ + 0x8f, 0xf6, 0x8f, 0xf6, 0x8f, 0xf6, 0x8f, 0xf6, + 0x8f, 0xf6, 0x8f, 0xf6, 0x8f, 0xf6, 0x8f, 0xf6, + 0x8f, 0xf6, 0x8f, 0xf6, 0x8f, 0xf6, 0x8f, 0xf6, + 0x8f, 0xf6, 0x8f, 0xf6, 0x8f, 0xf6, 0x8f, 0xf6, + 0x8f, 0xf6, 0x8f, 0xf6, 0x8f, 0xf6, 0x8f, 0xf6, + 0x8f, 0xf6, 0x8f, 0xf6, 0x8f, 0xf6, 0x8f, 0xf6, + 0x8f, 0xf6, 0x8f, 0xf6, 0x8f, 0xf6, 0x8f, 0xf6, + 0x8f, 0xf6, 0x8f, 0xf6, 0x8f, 0xf6, 0x8f, 0xf6, + 0x8f, 0xf6, 0x8f, 0xf6, + + /* U+007D "}" */ + 0x2f, 0xfe, 0xb4, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x3, 0xef, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0x20, 0x0, 0x0, 0x0, + 0xb, 0xff, 0x90, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf8, 0x20, 0x0, 0x0, 0x0, 0x4e, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x1, 0xdf, 0xf9, 0x0, 0x0, + 0x0, 0x3e, 0xff, 0xf9, 0x0, 0x0, 0x1, 0xef, + 0xf8, 0x20, 0x0, 0x0, 0xa, 0xff, 0x90, 0x0, + 0x0, 0x0, 0xf, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf8, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf6, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x2f, 0xfe, + 0xa3, 0x0, 0x0, 0x0, + + /* U+007E "~" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x39, 0xdf, 0xec, 0x82, 0x0, + 0x0, 0x0, 0x0, 0x27, 0x8, 0xff, 0xff, 0xff, + 0xff, 0xc6, 0x0, 0x0, 0x5, 0xe9, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0x88, 0xdf, 0xf9, + 0x6f, 0xfe, 0x97, 0x9e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf9, 0x6f, 0x70, 0x0, 0x0, 0x3a, 0xff, + 0xff, 0xff, 0xff, 0xb1, 0x54, 0x0, 0x0, 0x0, + 0x0, 0x17, 0xbe, 0xfe, 0xa4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00A0 " " */ + + /* U+00A3 "£" */ + 0x0, 0x0, 0x0, 0x4, 0xad, 0xff, 0xeb, 0x71, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3d, 0xff, 0xff, + 0xff, 0xff, 0xe6, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xcc, 0xef, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x4e, 0xff, + 0xf4, 0x0, 0x0, 0xa, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xc0, 0x0, 0x0, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x20, 0x0, + 0x2f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xe4, 0x0, 0x2, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x2, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x1b, 0xbb, 0xdf, 0xff, 0xbb, + 0xbb, 0xb3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xfa, 0x9b, 0xa8, 0x41, 0x0, 0x0, 0x0, + 0x21, 0x1, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x74, 0x25, 0xaf, 0x60, 0x2f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, 0xcf, + 0xf9, 0x41, 0x1, 0x5a, 0xff, 0xff, 0xff, 0xff, + 0xe0, 0x5, 0xa1, 0x0, 0x0, 0x0, 0x0, 0x49, + 0xdf, 0xea, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00A4 "¤" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3e, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3e, 0x40, 0x2e, 0xff, 0x50, 0x5b, 0xef, + 0xeb, 0x60, 0x4f, 0xff, 0x42, 0xef, 0xff, 0xdf, + 0xff, 0xff, 0xff, 0xef, 0xff, 0xe3, 0x2, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe2, 0x0, + 0x2, 0xff, 0xff, 0x72, 0x2, 0x7f, 0xff, 0xf4, + 0x0, 0x0, 0x7f, 0xff, 0x30, 0x0, 0x0, 0x2e, + 0xff, 0xa0, 0x0, 0xe, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x0, 0x2, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xf4, 0x0, 0x4f, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0x60, 0x4, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf6, + 0x0, 0x2f, 0xff, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0x40, 0x0, 0xef, 0xf6, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf0, 0x0, 0x8, 0xff, 0xf3, 0x0, + 0x0, 0x2, 0xef, 0xfa, 0x0, 0x0, 0x2f, 0xff, + 0xf7, 0x20, 0x27, 0xff, 0xff, 0x40, 0x0, 0x1d, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x30, + 0x1d, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xfe, 0xff, + 0xfe, 0x32, 0xef, 0xf5, 0x5, 0xbe, 0xfe, 0xc6, + 0x3, 0xff, 0xf4, 0x3, 0xe5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xe4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00A5 "¥" */ + 0xbf, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xc0, 0x2f, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x30, 0x8, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfa, + 0x0, 0x0, 0xef, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf1, 0x0, 0x0, 0x6f, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x70, 0x0, 0x0, + 0xc, 0xff, 0xd0, 0x0, 0x0, 0x0, 0xdf, 0xfe, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, 0x0, 0x0, + 0x7, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xfe, 0x10, 0x0, 0xe, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x90, 0x0, 0x8f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf2, + 0x1, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xfa, 0x9, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x5f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x0, 0x9, 0xbb, 0xbb, + 0xbb, 0xcf, 0xff, 0xcb, 0xbb, 0xbb, 0xba, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x7, 0x99, + 0x99, 0x99, 0x9f, 0xff, 0xa9, 0x99, 0x99, 0x98, + 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x0, 0xc, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, + + /* U+00A6 "¦" */ + 0x8f, 0xf6, 0x8f, 0xf6, 0x8f, 0xf6, 0x8f, 0xf6, + 0x8f, 0xf6, 0x8f, 0xf6, 0x8f, 0xf6, 0x8f, 0xf6, + 0x8f, 0xf6, 0x8f, 0xf6, 0x8f, 0xf6, 0x8f, 0xf6, + 0x8f, 0xf6, 0x8f, 0xf6, 0x48, 0x83, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x49, 0x93, + 0x8f, 0xf6, 0x8f, 0xf6, 0x8f, 0xf6, 0x8f, 0xf6, + 0x8f, 0xf6, 0x8f, 0xf6, 0x8f, 0xf6, 0x8f, 0xf6, + 0x8f, 0xf6, 0x8f, 0xf6, 0x8f, 0xf6, 0x8f, 0xf6, + 0x8f, 0xf6, 0x8f, 0xf6, + + /* U+00A7 "§" */ + 0x0, 0x0, 0x2, 0x9d, 0xff, 0xec, 0x71, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xdc, + 0xef, 0xff, 0xf6, 0x0, 0x0, 0x2, 0xff, 0xfb, + 0x20, 0x0, 0x4e, 0xff, 0xf1, 0x0, 0x0, 0x7f, + 0xfe, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x70, 0x0, + 0x9, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xdf, 0xfb, + 0x0, 0x0, 0x8f, 0xfd, 0x0, 0x0, 0x0, 0x5, + 0x75, 0x30, 0x0, 0x3, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfb, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xfe, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xdf, 0xff, 0xff, 0xc3, 0x0, 0x0, 0x0, + 0x0, 0x1c, 0xff, 0xd7, 0xff, 0xff, 0xf9, 0x10, + 0x0, 0x0, 0xb, 0xff, 0xb0, 0x2, 0xbf, 0xff, + 0xfe, 0x50, 0x0, 0x2, 0xff, 0xe0, 0x0, 0x0, + 0x6e, 0xff, 0xff, 0xa0, 0x0, 0x6f, 0xfa, 0x0, + 0x0, 0x0, 0x1a, 0xff, 0xff, 0xd1, 0x6, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xb0, + 0x3f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x2, 0xef, + 0xff, 0x20, 0xcf, 0xfd, 0x10, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf6, 0x2, 0xff, 0xfe, 0x40, 0x0, + 0x0, 0x0, 0xc, 0xff, 0x70, 0x3, 0xef, 0xff, + 0xa1, 0x0, 0x0, 0x0, 0xcf, 0xf4, 0x0, 0x1, + 0xbf, 0xff, 0xe6, 0x0, 0x0, 0x1f, 0xfe, 0x0, + 0x0, 0x0, 0x5e, 0xff, 0xfc, 0x30, 0x1c, 0xfe, + 0x30, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x9e, + 0xf9, 0x10, 0x0, 0x0, 0x0, 0x0, 0x2, 0xcf, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2c, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xe0, + 0x0, 0x19, 0xbd, 0x30, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x10, 0x1, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf2, 0x0, 0xc, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x0, 0x0, 0x4f, 0xff, + 0xe4, 0x0, 0x1, 0x9f, 0xff, 0xa0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xde, 0xff, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xc1, + 0x0, 0x0, 0x0, 0x0, 0x17, 0xce, 0xff, 0xda, + 0x40, 0x0, 0x0, + + /* U+00A8 "¨" */ + 0xac, 0xc7, 0x0, 0xb, 0xcc, 0x6e, 0xff, 0xa0, + 0x0, 0xff, 0xf8, 0xef, 0xfa, 0x0, 0xf, 0xff, + 0x8e, 0xff, 0xa0, 0x0, 0xff, 0xf8, + + /* U+00A9 "©" */ + 0x0, 0x0, 0x0, 0x0, 0x3, 0x8b, 0xef, 0xfe, + 0xc9, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xcf, + 0xff, 0xd9, 0x75, 0x56, 0x9d, 0xff, 0xfc, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xb3, 0x0, + 0x0, 0x0, 0x0, 0x3b, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5e, 0xff, 0x40, 0x0, 0x0, 0x2f, + 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xdf, 0xf2, 0x0, 0x0, 0xcf, 0xf2, 0x0, + 0x0, 0x29, 0xdf, 0xfe, 0xa3, 0x0, 0x0, 0x2e, + 0xfc, 0x0, 0x5, 0xff, 0x40, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x5, 0xff, 0x60, + 0xd, 0xfb, 0x0, 0x0, 0x9f, 0xfc, 0x51, 0x14, + 0xbf, 0xf8, 0x0, 0x0, 0xbf, 0xe0, 0x3f, 0xf3, + 0x0, 0x3, 0xff, 0xb0, 0x0, 0x0, 0x9, 0xff, + 0x20, 0x0, 0x3f, 0xf4, 0x8f, 0xe0, 0x0, 0xb, + 0xff, 0x10, 0x0, 0x0, 0x0, 0xda, 0x30, 0x0, + 0xd, 0xf9, 0xcf, 0x90, 0x0, 0xf, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xfc, + 0xef, 0x70, 0x0, 0x3f, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xfe, 0xff, 0x50, + 0x0, 0x4f, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0x50, 0x0, 0x4f, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xef, 0x70, 0x0, 0x3f, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xfe, + 0xcf, 0x90, 0x0, 0xf, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x55, 0x10, 0x0, 0x9, 0xfc, 0x9f, 0xd0, + 0x0, 0xb, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xa0, 0x0, 0xd, 0xf9, 0x4f, 0xf3, 0x0, 0x4, + 0xff, 0x90, 0x0, 0x0, 0xb, 0xff, 0x30, 0x0, + 0x3f, 0xf4, 0xe, 0xfb, 0x0, 0x0, 0xaf, 0xfa, + 0x30, 0x15, 0xdf, 0xfa, 0x0, 0x0, 0xbf, 0xe0, + 0x6, 0xff, 0x40, 0x0, 0xb, 0xff, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0x4, 0xff, 0x60, 0x0, 0xdf, + 0xf2, 0x0, 0x0, 0x5c, 0xff, 0xff, 0xb4, 0x0, + 0x0, 0x2e, 0xfc, 0x0, 0x0, 0x2f, 0xfe, 0x20, + 0x0, 0x0, 0x1, 0x20, 0x0, 0x0, 0x2, 0xdf, + 0xf2, 0x0, 0x0, 0x4, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4e, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xb3, 0x0, 0x0, 0x0, + 0x0, 0x2b, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xdf, 0xff, 0xd9, 0x65, 0x56, 0x9d, 0xff, + 0xfc, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x9c, + 0xef, 0xfe, 0xc9, 0x40, 0x0, 0x0, 0x0, 0x0, + + /* U+00AA "ª" */ + 0x0, 0x4, 0xbe, 0xfd, 0x70, 0x2f, 0xf8, 0x0, + 0x8f, 0xff, 0xff, 0xfc, 0x7f, 0xf4, 0x5, 0xff, + 0xe5, 0x13, 0xcf, 0xff, 0xf0, 0xd, 0xff, 0x30, + 0x0, 0x1e, 0xff, 0xc0, 0x2f, 0xfc, 0x0, 0x0, + 0x8, 0xff, 0x80, 0x5f, 0xf8, 0x0, 0x0, 0x4, + 0xff, 0x50, 0x6f, 0xf7, 0x0, 0x0, 0x3, 0xff, + 0x20, 0x6f, 0xf7, 0x0, 0x0, 0x4, 0xff, 0x20, + 0x4f, 0xf9, 0x0, 0x0, 0x5, 0xff, 0x60, 0x1f, + 0xfc, 0x0, 0x0, 0xa, 0xff, 0x90, 0xc, 0xff, + 0x30, 0x0, 0x2f, 0xff, 0xd0, 0x4, 0xff, 0xd4, + 0x14, 0xdf, 0xff, 0xf2, 0x0, 0x7f, 0xff, 0xff, + 0xfd, 0x5f, 0xf7, 0x0, 0x4, 0xbe, 0xfd, 0x80, + 0x3, 0x42, + + /* U+00AB "«" */ + 0x0, 0x0, 0x0, 0x9c, 0xb0, 0x0, 0x7, 0xcc, + 0x30, 0x0, 0x0, 0x6f, 0xf7, 0x0, 0x4, 0xff, + 0xb0, 0x0, 0x0, 0x2f, 0xfd, 0x0, 0x0, 0xef, + 0xf2, 0x0, 0x0, 0xc, 0xff, 0x50, 0x0, 0xaf, + 0xf8, 0x0, 0x0, 0x8, 0xff, 0xc0, 0x0, 0x5f, + 0xfe, 0x0, 0x0, 0x4, 0xff, 0xf3, 0x0, 0x1e, + 0xff, 0x60, 0x0, 0x1, 0xef, 0xf9, 0x0, 0xb, + 0xff, 0xc0, 0x0, 0x0, 0xaf, 0xff, 0x10, 0x6, + 0xff, 0xf3, 0x0, 0x0, 0x4f, 0xff, 0x80, 0x0, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0xcf, 0xfd, 0x0, + 0x8, 0xff, 0xf1, 0x0, 0x0, 0x2, 0xff, 0xf7, + 0x0, 0xd, 0xff, 0xa0, 0x0, 0x0, 0x6, 0xff, + 0xf1, 0x0, 0x3f, 0xff, 0x40, 0x0, 0x0, 0xb, + 0xff, 0x90, 0x0, 0x7f, 0xfd, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0x30, 0x0, 0xcf, 0xf6, 0x0, 0x0, + 0x0, 0x4f, 0xfc, 0x0, 0x2, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x9f, 0xf5, 0x0, 0x6, 0xff, 0x90, + 0x0, 0x0, 0x0, 0xdf, 0xd0, 0x0, 0xb, 0xff, + 0x30, + + /* U+00AC "¬" */ + 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, + 0x11, 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf1, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x1e, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xf1, + + /* U+00AD "­" */ + 0x45, 0x55, 0x55, 0x55, 0x55, 0x2c, 0xff, 0xff, + 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0x7c, 0xff, 0xff, 0xff, 0xff, 0xf7, + + /* U+00AE "®" */ + 0x0, 0x0, 0x0, 0x0, 0x3, 0x8b, 0xef, 0xfe, + 0xc9, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xcf, + 0xff, 0xd9, 0x75, 0x56, 0x9d, 0xff, 0xfc, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xb3, 0x0, + 0x0, 0x0, 0x0, 0x3b, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5e, 0xff, 0x40, 0x0, 0x0, 0x2f, + 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xdf, 0xf2, 0x0, 0x0, 0xcf, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, + 0xfc, 0x0, 0x5, 0xff, 0x40, 0x2, 0xff, 0xff, + 0xff, 0xfe, 0xb5, 0x0, 0x0, 0x5, 0xff, 0x60, + 0xd, 0xfb, 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0xbf, 0xe0, 0x3f, 0xf3, + 0x0, 0x2, 0xff, 0x40, 0x0, 0x14, 0xdf, 0xf2, + 0x0, 0x0, 0x3f, 0xf4, 0x8f, 0xe0, 0x0, 0x2, + 0xff, 0x40, 0x0, 0x0, 0x3f, 0xf6, 0x0, 0x0, + 0xd, 0xf9, 0xcf, 0x90, 0x0, 0x2, 0xff, 0x40, + 0x0, 0x0, 0x3f, 0xf6, 0x0, 0x0, 0x9, 0xfc, + 0xef, 0x70, 0x0, 0x2, 0xff, 0x40, 0x0, 0x15, + 0xdf, 0xe1, 0x0, 0x0, 0x6, 0xfe, 0xff, 0x50, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x5, 0xff, 0xff, 0x50, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xfc, 0x71, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xef, 0x70, 0x0, 0x2, 0xff, 0x51, + 0x28, 0xff, 0x50, 0x0, 0x0, 0x0, 0x7, 0xfe, + 0xcf, 0x90, 0x0, 0x2, 0xff, 0x40, 0x0, 0x7f, + 0xf3, 0x0, 0x0, 0x0, 0x9, 0xfc, 0x9f, 0xd0, + 0x0, 0x2, 0xff, 0x40, 0x0, 0xc, 0xfe, 0x0, + 0x0, 0x0, 0xd, 0xf9, 0x4f, 0xf3, 0x0, 0x2, + 0xff, 0x40, 0x0, 0x3, 0xff, 0x90, 0x0, 0x0, + 0x3f, 0xf4, 0xe, 0xfb, 0x0, 0x2, 0xff, 0x40, + 0x0, 0x0, 0x9f, 0xf3, 0x0, 0x0, 0xbf, 0xe0, + 0x6, 0xff, 0x40, 0x2, 0xff, 0x40, 0x0, 0x0, + 0x1f, 0xfc, 0x0, 0x4, 0xff, 0x60, 0x0, 0xdf, + 0xf2, 0x1, 0xaa, 0x30, 0x0, 0x0, 0x6, 0xaa, + 0x30, 0x2e, 0xfc, 0x0, 0x0, 0x2f, 0xfe, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xdf, + 0xf2, 0x0, 0x0, 0x4, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4e, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xb3, 0x0, 0x0, 0x0, + 0x0, 0x2b, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xdf, 0xff, 0xd9, 0x65, 0x56, 0x9d, 0xff, + 0xfc, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x9c, + 0xef, 0xfe, 0xc9, 0x40, 0x0, 0x0, 0x0, 0x0, + + /* U+00B0 "°" */ + 0x0, 0x18, 0xdf, 0xea, 0x20, 0x0, 0x2e, 0xff, + 0xff, 0xff, 0x40, 0xd, 0xfc, 0x30, 0x2a, 0xff, + 0x14, 0xfe, 0x10, 0x0, 0xc, 0xf7, 0x7f, 0x90, + 0x0, 0x0, 0x6f, 0xb8, 0xf9, 0x0, 0x0, 0x6, + 0xfb, 0x4f, 0xe0, 0x0, 0x0, 0xcf, 0x80, 0xdf, + 0xc3, 0x2, 0xaf, 0xf1, 0x2, 0xef, 0xff, 0xff, + 0xf4, 0x0, 0x1, 0x8d, 0xfe, 0xa2, 0x0, + + /* U+00B1 "±" */ + 0x0, 0x0, 0x0, 0x6, 0xdd, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x1, 0x11, 0x11, 0x11, 0x8f, 0xfb, + 0x11, 0x11, 0x11, 0x10, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x1e, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x7f, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x11, 0x11, 0x11, + 0x11, 0x11, 0x11, 0x11, 0x11, 0x10, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1e, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf1, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x10, + + /* U+00B2 "²" */ + 0x0, 0x5, 0xbe, 0xff, 0xc8, 0x10, 0x0, 0xbf, + 0xff, 0xff, 0xff, 0xe1, 0x8, 0xff, 0xc5, 0x35, + 0xdf, 0xfa, 0xe, 0xfe, 0x0, 0x0, 0x2f, 0xfe, + 0x1, 0x33, 0x0, 0x0, 0xf, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf8, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xe1, 0x0, 0x0, 0x1, 0xaf, 0xfe, 0x20, + 0x0, 0x0, 0x3d, 0xff, 0xc1, 0x0, 0x0, 0x5, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x50, + 0x0, 0x0, 0x5, 0xff, 0xf7, 0x44, 0x44, 0x44, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xff, + + /* U+00B3 "³" */ + 0x0, 0x18, 0xdf, 0xfe, 0xc7, 0x0, 0x1, 0xef, + 0xff, 0xff, 0xff, 0xc0, 0xb, 0xff, 0x82, 0x14, + 0xef, 0xf3, 0x5, 0x77, 0x0, 0x0, 0xaf, 0xf4, + 0x0, 0x0, 0x0, 0x15, 0xff, 0xd0, 0x0, 0x0, + 0x9, 0xff, 0xf9, 0x10, 0x0, 0x0, 0xc, 0xff, + 0xfd, 0x50, 0x0, 0x0, 0x0, 0x13, 0xcf, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xfd, 0x3, 0x52, + 0x0, 0x0, 0xf, 0xff, 0x3f, 0xfb, 0x0, 0x0, + 0x5f, 0xfd, 0xc, 0xff, 0xa4, 0x37, 0xff, 0xf7, + 0x2, 0xef, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x18, + 0xcf, 0xfe, 0xb5, 0x0, + + /* U+00B5 "µ" */ + 0x6f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0x86, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xf8, 0x6f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0x86, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xf8, 0x6f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0x86, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xf8, 0x6f, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0x86, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xf8, 0x6f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0x86, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xf8, 0x6f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0x86, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf8, 0x6f, 0xff, + 0x10, 0x0, 0x0, 0x0, 0xe, 0xff, 0x86, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf8, 0x6f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x86, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x3f, 0xff, 0xf8, + 0x6f, 0xff, 0xff, 0x71, 0x2, 0x8f, 0xff, 0xff, + 0x86, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, + 0xf8, 0x6f, 0xfe, 0x5f, 0xff, 0xff, 0xff, 0x77, + 0xff, 0x86, 0xff, 0xe0, 0x29, 0xef, 0xea, 0x40, + 0x7f, 0xf8, 0x6f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00B6 "¶" */ + 0x0, 0x0, 0x4, 0x9d, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf7, 0x0, 0x2, 0xdf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf7, 0x0, 0xef, 0xff, 0xff, 0xff, 0xf9, 0x22, + 0x27, 0xff, 0xd2, 0x21, 0x7, 0xff, 0xff, 0xff, + 0xff, 0xf7, 0x0, 0x6, 0xff, 0xc0, 0x0, 0xc, + 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x6, 0xff, + 0xc0, 0x0, 0xf, 0xff, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x6, 0xff, 0xc0, 0x0, 0xf, 0xff, 0xff, + 0xff, 0xff, 0xf7, 0x0, 0x6, 0xff, 0xc0, 0x0, + 0xf, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x6, + 0xff, 0xc0, 0x0, 0xd, 0xff, 0xff, 0xff, 0xff, + 0xf7, 0x0, 0x6, 0xff, 0xc0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0xff, 0xf7, 0x0, 0x6, 0xff, 0xc0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x6, 0xff, 0xc0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xff, 0xf7, 0x0, 0x6, 0xff, 0xc0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x6, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x17, 0xce, 0xff, 0xf7, + 0x0, 0x6, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xf7, 0x0, 0x6, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf7, 0x0, 0x6, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xf7, 0x0, 0x6, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf7, 0x0, 0x6, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf7, 0x0, + 0x6, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf7, 0x0, 0x6, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf7, 0x0, 0x6, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf7, + 0x0, 0x6, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xf7, 0x0, 0x6, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf7, 0x0, 0x6, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xf7, 0x0, 0x6, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf7, 0x0, 0x6, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf7, 0x0, + 0x6, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf7, 0x0, 0x6, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf7, 0x0, 0x6, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf7, + 0x0, 0x6, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xf7, 0x0, 0x6, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf7, 0x0, 0x6, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xf7, 0x0, 0x6, 0xff, 0xc0, 0x0, + + /* U+00B7 "·" */ + 0x7c, 0xcc, 0x29, 0xff, 0xf3, 0x9f, 0xff, 0x39, + 0xff, 0xf3, + + /* U+00BB "»" */ + 0x1c, 0xc9, 0x0, 0x0, 0xac, 0xb0, 0x0, 0x0, + 0x0, 0x9f, 0xf5, 0x0, 0x5, 0xff, 0x80, 0x0, + 0x0, 0x1, 0xef, 0xe1, 0x0, 0xc, 0xff, 0x40, + 0x0, 0x0, 0x6, 0xff, 0xb0, 0x0, 0x3f, 0xfe, + 0x10, 0x0, 0x0, 0xd, 0xff, 0x70, 0x0, 0xaf, + 0xfa, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x20, 0x1, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0xaf, 0xfc, 0x0, + 0x7, 0xff, 0xf2, 0x0, 0x0, 0x1, 0xff, 0xf8, + 0x0, 0xd, 0xff, 0xc0, 0x0, 0x0, 0x9, 0xff, + 0xf2, 0x0, 0x6f, 0xff, 0x60, 0x0, 0x0, 0xef, + 0xfa, 0x0, 0xc, 0xff, 0xe1, 0x0, 0x0, 0x8f, + 0xfe, 0x10, 0x5, 0xff, 0xf4, 0x0, 0x0, 0x2f, + 0xff, 0x40, 0x0, 0xef, 0xf8, 0x0, 0x0, 0xb, + 0xff, 0x90, 0x0, 0x7f, 0xfc, 0x0, 0x0, 0x4, + 0xff, 0xd0, 0x0, 0x1f, 0xff, 0x20, 0x0, 0x0, + 0xdf, 0xf3, 0x0, 0xa, 0xff, 0x60, 0x0, 0x0, + 0x7f, 0xf8, 0x0, 0x3, 0xff, 0xb0, 0x0, 0x0, + 0x1f, 0xfc, 0x0, 0x0, 0xcf, 0xe1, 0x0, 0x0, + 0x0, + + /* U+00BD "½" */ + 0x0, 0x0, 0x9, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x2c, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xc0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xf2, 0x0, 0x0, 0x0, 0xf, 0xfc, + 0x2d, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf5, 0x0, 0x0, 0x0, 0x0, 0xa4, 0x0, + 0xdf, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xd0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xd0, 0x0, + 0x0, 0x0, 0x9f, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xfd, 0x0, 0x0, + 0x0, 0x4f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xc0, 0x0, 0x0, + 0x1e, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0x30, 0x0, 0x5, 0xbe, 0xff, 0xc8, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0x70, 0x0, 0xb, 0xff, 0xff, 0xff, 0xfe, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xb0, + 0x0, 0x8, 0xff, 0xc5, 0x35, 0xcf, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xe1, 0x0, + 0x0, 0xef, 0xe0, 0x0, 0x2, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf5, 0x0, 0x0, + 0x1, 0x33, 0x0, 0x0, 0xf, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3d, 0xff, 0xd2, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x73, + 0x33, 0x33, 0x30, 0x0, 0x0, 0x5f, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x1e, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x4, 0x88, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0384 "΄" */ + 0x0, 0x12, 0x22, 0x20, 0xb, 0xff, 0xf7, 0x3, + 0xff, 0xfa, 0x0, 0xaf, 0xfd, 0x0, 0x2f, 0xfe, + 0x20, 0xa, 0xff, 0x40, 0x0, + + /* U+0386 "Ά" */ + 0x0, 0x0, 0xcf, 0xff, 0x70, 0xc, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xa0, 0x2, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xd0, 0x0, + 0x8f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xe2, 0x0, 0xe, 0xff, 0xaf, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xf4, 0x0, 0x5, 0xff, 0xe3, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x22, 0x0, 0x0, + 0xbf, 0xf9, 0xd, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x40, + 0x8f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf0, 0x2, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xfa, 0x0, 0xc, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x40, + 0x0, 0x6f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xe0, 0x0, 0x0, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf8, 0x0, 0x0, 0xa, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x20, + 0x0, 0x0, 0x4f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0xef, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xee, + 0xee, 0xee, 0xee, 0xee, 0xef, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x50, 0x0, 0x0, 0x8, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0xef, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf2, + 0x0, 0x0, 0x4f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x90, 0x0, 0xa, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0x0, 0x1, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf6, 0x0, 0x7f, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xd0, 0xd, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x30, + + /* U+0388 "Έ" */ + 0x0, 0x6f, 0xff, 0xc0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0x0, + 0xef, 0xfe, 0x10, 0x9, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0x6, 0xff, + 0xf3, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf1, 0xd, 0xff, 0x60, + 0x0, 0x9, 0xff, 0xf3, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x22, 0x22, 0x20, 0x5f, 0xfa, 0x0, 0x0, + 0x9, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x12, 0x20, 0x0, 0x0, 0x9, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf3, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x22, 0x22, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf3, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x32, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfb, + + /* U+0389 "Ή" */ + 0x0, 0x6f, 0xff, 0xc0, 0x5f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x0, + 0xd, 0xff, 0xe1, 0x5, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf0, 0x5, + 0xff, 0xf4, 0x0, 0x5f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x0, 0xdf, + 0xf7, 0x0, 0x5, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf0, 0x5f, 0xfa, + 0x0, 0x0, 0x5f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0x1, 0x22, 0x0, + 0x0, 0x5, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x63, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0xaf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0x0, + + /* U+038A "Ί" */ + 0x0, 0x6f, 0xff, 0xc0, 0x5f, 0xff, 0x40, 0xd, + 0xff, 0xe1, 0x5, 0xff, 0xf4, 0x5, 0xff, 0xf4, + 0x0, 0x5f, 0xff, 0x40, 0xdf, 0xf7, 0x0, 0x5, + 0xff, 0xf4, 0x5f, 0xfa, 0x0, 0x0, 0x5f, 0xff, + 0x41, 0x22, 0x0, 0x0, 0x5, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x40, + + /* U+038C "Ό" */ + 0x0, 0x6f, 0xff, 0xc0, 0x0, 0x1, 0x5a, 0xde, + 0xfe, 0xdb, 0x72, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xfe, 0x10, 0x1, 0x9f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb3, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xf3, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0xd, 0xff, 0x60, + 0x7, 0xff, 0xff, 0xe9, 0x52, 0x12, 0x48, 0xdf, + 0xff, 0xfb, 0x0, 0x0, 0x5f, 0xfa, 0x0, 0x6f, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0x90, 0x0, 0x12, 0x20, 0x2, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x70, + 0x0, 0x0, 0x9f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0xdf, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf1, 0x0, 0x1, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xf5, 0x0, 0x3, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf7, 0x0, 0x4, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf8, 0x0, 0x5, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xf9, 0x0, 0x5, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xf9, 0x0, 0x4, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf7, + 0x0, 0x1, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf5, 0x0, + 0x0, 0xdf, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf2, 0x0, 0x0, + 0x9f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x3f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x70, 0x0, 0x0, 0xb, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2d, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xef, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xe8, + 0x42, 0x11, 0x37, 0xdf, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x9f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x6a, 0xde, 0xfe, 0xdb, + 0x72, 0x0, 0x0, 0x0, 0x0, + + /* U+038E "Ύ" */ + 0x0, 0x6f, 0xff, 0xc0, 0x9, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xfa, 0x0, 0xef, 0xfe, 0x10, 0x0, 0xef, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xe0, 0x6, 0xff, 0xf3, 0x0, 0x0, 0x4f, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x40, 0xd, 0xff, 0x60, 0x0, 0x0, + 0x9, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xf8, 0x0, 0x5f, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xd0, 0x0, 0x12, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x60, 0x0, 0x0, 0x3f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xe1, 0x0, 0x0, 0xdf, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xfa, 0x0, 0x7, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x40, 0x2f, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xd0, 0xbf, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xfb, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+038F "Ώ" */ + 0x0, 0x6f, 0xff, 0xc0, 0x0, 0x1, 0x6a, 0xdf, + 0xff, 0xdb, 0x61, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xe1, 0x0, 0x19, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf9, 0x10, 0x0, 0x0, 0x6, 0xff, 0xf3, + 0x0, 0x4e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x30, 0x0, 0x0, 0xdf, 0xf6, 0x0, 0x5f, + 0xff, 0xff, 0x94, 0x21, 0x25, 0xaf, 0xff, 0xff, + 0x30, 0x0, 0x5f, 0xfa, 0x0, 0x3f, 0xff, 0xfb, + 0x20, 0x0, 0x0, 0x0, 0x3d, 0xff, 0xfe, 0x10, + 0x1, 0x22, 0x0, 0xd, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1d, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xa0, 0x0, 0x0, 0x2f, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xfe, 0x0, 0x0, 0x6, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf3, 0x0, 0x0, 0x9f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x50, + 0x0, 0xa, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf7, 0x0, 0x0, + 0xbf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0x80, 0x0, 0xa, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf7, 0x0, 0x0, 0x9f, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0x60, 0x0, 0x6, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf3, + 0x0, 0x0, 0x2f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfe, 0x0, 0x0, + 0x0, 0xdf, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0x90, 0x0, 0x0, 0x6, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf3, 0x0, 0x0, 0x0, 0xd, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfe, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xfe, 0x30, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x3, + 0x33, 0x33, 0x9f, 0xff, 0x91, 0x0, 0x2, 0xaf, + 0xff, 0x73, 0x33, 0x32, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x90, 0x0, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0xf, 0xff, 0xff, 0xff, + 0xff, 0xf9, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x90, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xd0, + + /* U+0390 "ΐ" */ + 0x0, 0x0, 0x0, 0xe, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xfc, 0x0, 0x0, 0x8f, 0xfb, + 0x0, 0xcf, 0xf2, 0x4f, 0xff, 0x8f, 0xfb, 0x3, + 0xff, 0x60, 0x4f, 0xff, 0x8f, 0xfb, 0xa, 0xfc, + 0x0, 0x4f, 0xff, 0x48, 0x86, 0x8, 0x82, 0x0, + 0x28, 0x88, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xe0, 0x0, 0x0, + + /* U+0391 "Α" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xaf, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xe3, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xfa, 0xd, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x50, + 0x8f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf0, 0x2, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xfa, 0x0, 0xc, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x40, + 0x0, 0x6f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xe0, 0x0, 0x0, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf8, 0x0, 0x0, 0xa, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x20, + 0x0, 0x0, 0x4f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0xef, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xee, + 0xee, 0xee, 0xee, 0xee, 0xef, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x50, 0x0, 0x0, 0x8, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0xef, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf2, + 0x0, 0x0, 0x4f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x90, 0x0, 0xa, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0x0, 0x1, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf6, 0x0, 0x7f, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xd0, 0xd, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x30, + + /* U+0392 "Β" */ + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xec, 0x94, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd4, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x3f, 0xff, 0x82, 0x22, 0x22, 0x33, 0x58, + 0xcf, 0xff, 0xf2, 0x0, 0x3f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf9, 0x0, 0x3f, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xfe, 0x0, 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x0, 0x3f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfe, 0x0, + 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xfb, 0x0, 0x3f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xf4, 0x0, 0x3f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x24, 0x9f, 0xff, 0x90, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb3, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x3f, 0xff, 0x83, 0x33, 0x33, 0x33, + 0x46, 0xbf, 0xff, 0xfb, 0x0, 0x3f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xcf, 0xff, 0x60, + 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xe0, 0x3f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf2, 0x3f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf4, 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xf4, 0x3f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf3, 0x3f, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xe0, 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xbf, 0xff, 0x90, 0x3f, 0xff, 0x83, + 0x33, 0x33, 0x33, 0x46, 0x9f, 0xff, 0xfe, 0x10, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x20, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xed, 0xb8, 0x30, 0x0, + 0x0, + + /* U+0393 "Γ" */ + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf0, 0xff, 0xfb, 0x22, 0x22, 0x22, + 0x22, 0x22, 0x22, 0x20, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+0394 "Δ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xaf, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xd3, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf9, 0xe, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x40, + 0x8f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xe0, 0x2, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xf9, 0x0, 0xc, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x30, + 0x0, 0x6f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xd0, 0x0, 0x0, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xf8, 0x0, 0x0, 0xa, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x20, + 0x0, 0x0, 0x4f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0xdf, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x50, 0x0, 0x0, 0x8, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0xef, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf2, + 0x0, 0x0, 0x4f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x90, 0x0, 0xa, + 0xff, 0xf4, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x34, 0xff, 0xfe, 0x0, 0x1, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0xd, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x30, + + /* U+0395 "Ε" */ + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xa0, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0xf, + 0xff, 0xa2, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x10, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xa2, 0x22, 0x22, + 0x22, 0x22, 0x22, 0x22, 0x21, 0x0, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xa0, 0xf, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xa3, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x30, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x50, + + /* U+0396 "Ζ" */ + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x0, 0xb, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x0, 0x2, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x22, 0x23, 0xef, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfd, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x53, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x30, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x35, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, + + /* U+0397 "Η" */ + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf6, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf6, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf6, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf6, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf6, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf6, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf6, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0xff, 0xfb, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x35, 0xff, 0xf6, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf6, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf6, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf6, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf6, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf6, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf6, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf6, + + /* U+0398 "Θ" */ + 0x0, 0x0, 0x0, 0x0, 0x5, 0x9c, 0xef, 0xfd, + 0xb7, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xfa, 0x53, 0x12, + 0x37, 0xcf, 0xff, 0xfc, 0x10, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xa1, 0x0, 0x0, 0x0, 0x0, 0x4e, + 0xff, 0xfc, 0x0, 0x0, 0x1, 0xef, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xf8, + 0x0, 0x0, 0x8f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xf2, 0x0, 0x1f, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x90, 0x6, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x0, 0xaf, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf4, 0xe, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0x80, 0xff, 0xfa, 0x0, + 0x1, 0x22, 0x22, 0x22, 0x22, 0x22, 0x0, 0x1, + 0xff, 0xfa, 0x1f, 0xff, 0x90, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0xf, 0xff, 0xb3, + 0xff, 0xf8, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x20, 0x0, 0xff, 0xfc, 0x3f, 0xff, 0x80, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x0, + 0xf, 0xff, 0xb1, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfa, + 0xf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x80, 0xbf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xf4, 0x6, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x0, 0x1f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xa0, 0x0, 0x9f, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xf2, 0x0, 0x1, 0xef, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1c, 0xff, 0xf9, + 0x0, 0x0, 0x4, 0xff, 0xff, 0x91, 0x0, 0x0, + 0x0, 0x0, 0x4d, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xe9, 0x42, 0x11, 0x37, 0xcf, + 0xff, 0xfc, 0x10, 0x0, 0x0, 0x0, 0x4, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x8f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xad, 0xef, 0xfd, 0xb7, + 0x30, 0x0, 0x0, 0x0, 0x0, + + /* U+0399 "Ι" */ + 0x8f, 0xff, 0x18, 0xff, 0xf1, 0x8f, 0xff, 0x18, + 0xff, 0xf1, 0x8f, 0xff, 0x18, 0xff, 0xf1, 0x8f, + 0xff, 0x18, 0xff, 0xf1, 0x8f, 0xff, 0x18, 0xff, + 0xf1, 0x8f, 0xff, 0x18, 0xff, 0xf1, 0x8f, 0xff, + 0x18, 0xff, 0xf1, 0x8f, 0xff, 0x18, 0xff, 0xf1, + 0x8f, 0xff, 0x18, 0xff, 0xf1, 0x8f, 0xff, 0x18, + 0xff, 0xf1, 0x8f, 0xff, 0x18, 0xff, 0xf1, 0x8f, + 0xff, 0x18, 0xff, 0xf1, 0x8f, 0xff, 0x18, 0xff, + 0xf1, 0x8f, 0xff, 0x10, + + /* U+039A "Κ" */ + 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0x40, 0x3f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf4, 0x0, + 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0x30, 0x0, 0x3f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xe3, 0x0, 0x0, + 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xfe, 0x20, 0x0, 0x0, 0x3f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xe2, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x60, 0x0, 0x0, 0xa, 0xff, 0xfd, + 0x20, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x60, 0x0, + 0x0, 0xaf, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x60, 0x0, 0xa, 0xff, 0xfd, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x60, 0x0, + 0xaf, 0xff, 0xc1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x60, 0xa, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x60, 0xaf, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x6a, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xef, 0xff, + 0xae, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xfa, 0x5, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0x90, + 0x0, 0x9f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf9, 0x0, 0x0, 0xd, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x90, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x3f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf3, 0x0, 0x0, + 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfe, 0x10, 0x0, 0x3f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xb0, 0x0, + 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf7, 0x0, 0x3f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x30, + 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xd0, + + /* U+039B "Λ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xaf, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0x2d, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfd, 0x8, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xf8, 0x3, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xf2, 0x0, 0xdf, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xc0, 0x0, 0x7f, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0x60, 0x0, 0x2f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x10, + 0x0, 0xc, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xfa, 0x0, 0x0, 0x6, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xf4, 0x0, 0x0, 0x1, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0xbf, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x80, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x20, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xfc, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0x20, 0x0, 0x0, 0x3f, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x80, + 0x0, 0x0, 0xaf, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xe0, 0x0, 0x0, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xf5, 0x0, 0x6, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfb, 0x0, + 0xc, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x10, 0x3f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0x80, 0x9f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xe0, + + /* U+039C "Μ" */ + 0x2f, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xd2, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xfd, 0x2f, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xd2, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xfd, 0x2f, 0xff, + 0xdf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xfe, 0xff, 0xd2, 0xff, 0xf7, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xfe, 0xaf, + 0xfd, 0x2f, 0xff, 0x5d, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0x9a, 0xff, 0xd2, 0xff, + 0xf5, 0x7f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xf4, 0xaf, 0xfd, 0x2f, 0xff, 0x52, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0xf, 0xfe, 0xa, + 0xff, 0xd2, 0xff, 0xf5, 0xc, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x5, 0xff, 0x80, 0xaf, 0xfd, 0x2f, + 0xff, 0x50, 0x7f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xf3, 0xa, 0xff, 0xd2, 0xff, 0xf5, 0x1, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0xf, 0xfd, 0x0, + 0xaf, 0xfd, 0x2f, 0xff, 0x50, 0xc, 0xff, 0x70, + 0x0, 0x0, 0x5, 0xff, 0x80, 0xa, 0xff, 0xd2, + 0xff, 0xf5, 0x0, 0x6f, 0xfd, 0x0, 0x0, 0x0, + 0xbf, 0xf2, 0x0, 0xaf, 0xfd, 0x2f, 0xff, 0x50, + 0x1, 0xff, 0xf2, 0x0, 0x0, 0x1f, 0xfc, 0x0, + 0xa, 0xff, 0xd2, 0xff, 0xf5, 0x0, 0xb, 0xff, + 0x70, 0x0, 0x6, 0xff, 0x70, 0x0, 0xaf, 0xfd, + 0x2f, 0xff, 0x50, 0x0, 0x6f, 0xfd, 0x0, 0x0, + 0xcf, 0xf1, 0x0, 0xa, 0xff, 0xd2, 0xff, 0xf5, + 0x0, 0x1, 0xff, 0xf2, 0x0, 0x1f, 0xfc, 0x0, + 0x0, 0xaf, 0xfd, 0x2f, 0xff, 0x50, 0x0, 0xb, + 0xff, 0x80, 0x7, 0xff, 0x60, 0x0, 0xa, 0xff, + 0xd2, 0xff, 0xf5, 0x0, 0x0, 0x6f, 0xfd, 0x0, + 0xcf, 0xf1, 0x0, 0x0, 0xaf, 0xfd, 0x2f, 0xff, + 0x50, 0x0, 0x1, 0xff, 0xf2, 0x2f, 0xfb, 0x0, + 0x0, 0xa, 0xff, 0xd2, 0xff, 0xf5, 0x0, 0x0, + 0xb, 0xff, 0x77, 0xff, 0x50, 0x0, 0x0, 0xaf, + 0xfd, 0x2f, 0xff, 0x50, 0x0, 0x0, 0x5f, 0xfd, + 0xcf, 0xf0, 0x0, 0x0, 0xa, 0xff, 0xd2, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0xaf, 0xfd, 0x2f, 0xff, 0x50, 0x0, + 0x0, 0xa, 0xff, 0xff, 0x40, 0x0, 0x0, 0xa, + 0xff, 0xd2, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0xaf, 0xfd, 0x2f, + 0xff, 0x50, 0x0, 0x0, 0x0, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xd0, + + /* U+039D "Ν" */ + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf7, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf7, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf7, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf7, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf7, 0xff, 0xf9, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xf7, 0xff, 0xf7, 0x6f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf7, + 0xff, 0xf7, 0xb, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf7, 0xff, 0xf7, 0x1, 0xef, 0xff, + 0x20, 0x0, 0x0, 0x0, 0xff, 0xf7, 0xff, 0xf7, + 0x0, 0x5f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0xff, + 0xf7, 0xff, 0xf7, 0x0, 0xb, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0xff, 0xf7, 0xff, 0xf7, 0x0, 0x1, + 0xef, 0xff, 0x20, 0x0, 0x0, 0xff, 0xf7, 0xff, + 0xf7, 0x0, 0x0, 0x5f, 0xff, 0xc0, 0x0, 0x0, + 0xff, 0xf7, 0xff, 0xf7, 0x0, 0x0, 0xa, 0xff, + 0xf7, 0x0, 0x0, 0xff, 0xf7, 0xff, 0xf7, 0x0, + 0x0, 0x1, 0xef, 0xff, 0x20, 0x0, 0xff, 0xf7, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xc0, + 0x0, 0xff, 0xf7, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf7, 0x0, 0xff, 0xf7, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0x20, 0xff, + 0xf7, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xd0, 0xff, 0xf7, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xf8, 0xff, 0xf7, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xff, 0xf7, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xf7, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf7, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xf7, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf7, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf7, + + /* U+039E "Ξ" */ + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x27, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf2, 0x7f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x21, + 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x2, 0x22, + 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x21, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x32, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xa0, + + /* U+039F "Ο" */ + 0x0, 0x0, 0x0, 0x0, 0x5, 0x9c, 0xef, 0xfd, + 0xb7, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xfa, 0x53, 0x12, + 0x37, 0xcf, 0xff, 0xfc, 0x10, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xa1, 0x0, 0x0, 0x0, 0x0, 0x4e, + 0xff, 0xfc, 0x0, 0x0, 0x1, 0xef, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xf8, + 0x0, 0x0, 0x8f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xf2, 0x0, 0x1f, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x90, 0x6, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x0, 0xaf, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf4, 0xe, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0x80, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xfa, 0x1f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xb3, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xfc, 0x3f, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xb1, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfa, + 0xf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x80, 0xbf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xf4, 0x6, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x0, 0x1f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xa0, 0x0, 0x9f, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xf2, 0x0, 0x1, 0xef, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1c, 0xff, 0xf9, + 0x0, 0x0, 0x4, 0xff, 0xff, 0x91, 0x0, 0x0, + 0x0, 0x0, 0x4d, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xe9, 0x42, 0x11, 0x37, 0xcf, + 0xff, 0xfc, 0x10, 0x0, 0x0, 0x0, 0x4, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x8f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xad, 0xef, 0xfd, 0xb7, + 0x30, 0x0, 0x0, 0x0, 0x0, + + /* U+03A0 "Π" */ + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf6, 0xff, 0xfb, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x25, 0xff, 0xf6, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf6, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf6, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf6, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf6, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf6, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf6, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf6, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf6, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf6, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf6, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf6, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf6, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf6, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf6, + + /* U+03A1 "Ρ" */ + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xda, + 0x72, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x1f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0x1f, 0xff, 0x92, 0x22, 0x22, 0x22, 0x34, + 0x6b, 0xff, 0xff, 0x80, 0x1f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf1, 0x1f, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf6, 0x1f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf9, 0x1f, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfa, + 0x1f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xfa, 0x1f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf8, 0x1f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf4, 0x1f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xd0, 0x1f, 0xff, 0x93, 0x33, + 0x33, 0x33, 0x35, 0x8e, 0xff, 0xff, 0x50, 0x1f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x50, 0x0, 0x1f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0xc9, 0x50, 0x0, 0x0, + 0x1f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+03A3 "Σ" */ + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf4, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x4f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x2f, 0xff, + 0xe4, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x20, + 0x6, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xfe, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xe4, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x4f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + + /* U+03A4 "Τ" */ + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x63, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x3f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x60, 0x22, 0x22, 0x22, 0x22, 0x5f, + 0xff, 0x72, 0x22, 0x22, 0x22, 0x21, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A5 "Υ" */ + 0x8f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xb0, 0xd, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xfe, 0x10, 0x3, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf4, 0x0, 0x0, + 0x8f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x90, 0x0, 0x0, 0xd, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf7, + 0x0, 0x0, 0x2, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x20, 0x0, 0xc, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xb0, 0x0, 0x6f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf5, + 0x1, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xfe, 0xa, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xbf, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A6 "Φ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7c, 0xcb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0x9c, 0xef, 0xff, 0xff, + 0xfe, 0xc9, 0x51, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x91, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x30, 0x0, 0x0, 0xb, 0xff, 0xff, 0xa5, 0x10, + 0xaf, 0xff, 0x1, 0x48, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x9f, 0xff, 0xd2, 0x0, 0x0, 0xaf, 0xff, + 0x0, 0x0, 0xa, 0xff, 0xfe, 0x10, 0x3, 0xff, + 0xfd, 0x10, 0x0, 0x0, 0xaf, 0xff, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0x80, 0xa, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf0, 0xf, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf5, + 0x3f, 0xff, 0x80, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf9, 0x5f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xfa, 0x6f, 0xff, 0x50, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xfb, 0x5f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfa, + 0x3f, 0xff, 0x80, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf8, 0xf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf4, 0xa, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf0, 0x3, 0xff, 0xfe, 0x20, 0x0, 0x0, + 0xaf, 0xff, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x70, + 0x0, 0x9f, 0xff, 0xe4, 0x0, 0x0, 0xaf, 0xff, + 0x0, 0x0, 0x1a, 0xff, 0xfd, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xc6, 0x20, 0xaf, 0xff, 0x1, 0x49, + 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x20, 0x0, 0x0, 0x0, 0x4, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0x7b, 0xde, 0xff, 0xff, + 0xed, 0xb8, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A7 "Χ" */ + 0x3, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xdf, 0xfe, 0x10, 0x0, 0x8f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf3, 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0x70, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x50, 0x0, 0x8, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xe1, 0x0, 0x4f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xfb, 0x1, 0xef, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x6b, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xef, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0x1c, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf5, 0x2, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xa0, + 0x0, 0x6f, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xfd, 0x0, 0x0, 0xa, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xf3, 0x0, 0x0, 0x1, 0xef, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x90, 0x0, + 0x1, 0xef, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf4, 0x0, 0xb, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xfe, 0x10, 0x7f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xb0, + + /* U+03A8 "Ψ" */ + 0xaf, 0xff, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, 0xaf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf6, 0xaf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf6, 0xaf, 0xff, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, + 0xaf, 0xff, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, 0xaf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf6, 0xaf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf6, 0xaf, 0xff, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf6, + 0x9f, 0xff, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf5, 0x8f, 0xff, + 0x10, 0x0, 0x0, 0x0, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xf4, 0x7f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xf2, 0x3f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf0, + 0xf, 0xff, 0xe0, 0x0, 0x0, 0x0, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xb0, 0x8, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0xff, 0xfa, 0x0, 0x0, + 0x1, 0xef, 0xff, 0x40, 0x1, 0xff, 0xff, 0xb2, + 0x0, 0x0, 0xff, 0xfa, 0x0, 0x0, 0x3d, 0xff, + 0xfc, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xa6, 0x20, + 0xff, 0xfb, 0x13, 0x6b, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, + 0x3b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x27, + 0xad, 0xef, 0xff, 0xff, 0xfe, 0xc9, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+03A9 "Ω" */ + 0x0, 0x0, 0x0, 0x0, 0x27, 0xbe, 0xff, 0xed, + 0xa6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xfe, 0x84, 0x21, 0x36, 0xbf, + 0xff, 0xfd, 0x10, 0x0, 0x0, 0x5, 0xff, 0xff, + 0x91, 0x0, 0x0, 0x0, 0x5, 0xef, 0xff, 0xc0, + 0x0, 0x0, 0x1e, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2e, 0xff, 0xf7, 0x0, 0x0, 0x9f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0x0, 0x0, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x70, + 0x5, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xc0, 0x9, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xf0, 0xc, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf2, 0xd, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf4, 0xe, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xf5, 0xd, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf4, 0xc, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xf3, 0x9, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, + 0x5, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xc0, 0x1, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x60, 0x0, 0x9f, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x0, 0x0, + 0x1f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xf7, 0x0, 0x0, 0x6, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0xaf, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xfe, 0x20, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xc2, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xe3, 0x0, 0x0, 0x3, 0x33, 0x33, 0xcf, 0xff, + 0x70, 0x0, 0x3, 0xcf, 0xff, 0x53, 0x33, 0x31, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0xf, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x3f, 0xff, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0xf, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xf6, + 0x0, 0xf, 0xff, 0xff, 0xff, 0xff, 0xfa, + + /* U+03AA "Ϊ" */ + 0xc, 0xcc, 0x50, 0x1, 0xcc, 0xc4, 0xf, 0xff, + 0x70, 0x1, 0xff, 0xf6, 0xf, 0xff, 0x70, 0x1, + 0xff, 0xf6, 0xf, 0xff, 0x70, 0x1, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x0, 0x0, + + /* U+03AB "Ϋ" */ + 0x0, 0x0, 0x0, 0x7, 0xcc, 0xa0, 0x0, 0x8c, + 0xc9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xe0, 0x0, 0xbf, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xe0, + 0x0, 0xbf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xe0, 0x0, 0xbf, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xb0, 0xd, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfe, 0x10, + 0x3, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf4, 0x0, 0x0, 0x8f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0x90, 0x0, 0x0, 0xd, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf7, 0x0, 0x0, + 0x2, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0x20, 0x0, 0xc, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xb0, 0x0, 0x6f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf5, 0x1, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xfe, 0xa, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xbf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03AC "ά" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x22, 0x22, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xbe, 0xfe, 0xc7, + 0x10, 0x0, 0xff, 0xf6, 0x0, 0x3, 0xef, 0xff, + 0xff, 0xff, 0xe3, 0x4, 0xff, 0xf1, 0x0, 0x4f, + 0xff, 0xff, 0xdc, 0xef, 0xff, 0x39, 0xff, 0xd0, + 0x1, 0xef, 0xff, 0x91, 0x0, 0x5, 0xef, 0xdd, + 0xff, 0x90, 0x9, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x40, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0x10, 0x4f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, + 0x7f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xfa, 0x0, 0x9f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xf6, 0x0, 0xaf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xf3, 0x0, 0xaf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf3, 0x0, + 0x8f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xf6, 0x0, 0x7f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xf9, 0x0, 0x3f, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xfd, 0x0, 0xe, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x0, + 0x8, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0x40, 0x0, 0xef, 0xff, 0x70, 0x0, 0x7, + 0xff, 0xbd, 0xff, 0x70, 0x0, 0x3f, 0xff, 0xff, + 0xcc, 0xff, 0xff, 0x39, 0xff, 0xb0, 0x0, 0x3, + 0xdf, 0xff, 0xff, 0xff, 0xf4, 0x4, 0xff, 0xf0, + 0x0, 0x0, 0x6, 0xbe, 0xfe, 0xc7, 0x10, 0x0, + 0xef, 0xf5, + + /* U+03AD "έ" */ + 0x0, 0x0, 0x0, 0x0, 0x22, 0x22, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xe2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5b, 0xef, 0xfd, 0x94, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xc2, 0x0, + 0x0, 0xaf, 0xff, 0xfe, 0xff, 0xff, 0xff, 0x10, + 0x3, 0xff, 0xf9, 0x10, 0x3, 0x9f, 0xe4, 0x0, + 0x8, 0xff, 0xd0, 0x0, 0x0, 0x2, 0x20, 0x0, + 0x9, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xfb, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xfe, 0xca, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xfd, 0x51, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0x90, 0x0, 0x0, 0x2, 0xd6, 0x0, + 0xa, 0xff, 0xf8, 0x0, 0x0, 0x6f, 0xff, 0x90, + 0x2, 0xff, 0xff, 0xfc, 0xcf, 0xff, 0xff, 0x60, + 0x0, 0x4e, 0xff, 0xff, 0xff, 0xff, 0xc3, 0x0, + 0x0, 0x1, 0x7c, 0xef, 0xed, 0x94, 0x0, 0x0, + + /* U+03AE "ή" */ + 0x0, 0x0, 0x0, 0x0, 0x2, 0x22, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0x90, 0x4, + 0xad, 0xff, 0xd9, 0x30, 0x0, 0x6f, 0xf9, 0x1a, + 0xff, 0xff, 0xff, 0xff, 0x80, 0x6, 0xff, 0x9c, + 0xff, 0xfe, 0xef, 0xff, 0xff, 0x70, 0x6f, 0xff, + 0xff, 0x81, 0x0, 0x17, 0xff, 0xff, 0x16, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x7, 0xff, 0xf4, 0x6f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x76, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf8, + 0x6f, 0xff, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0x96, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xf9, 0x6f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0x96, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xf9, 0x6f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0x96, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xf9, 0x6f, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0x96, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xf9, 0x6f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0x96, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xf9, 0x6f, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0x96, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf9, 0x6f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xf9, + + /* U+03AF "ί" */ + 0x0, 0xc, 0xff, 0xf6, 0x0, 0x4f, 0xff, 0xa0, + 0x0, 0xbf, 0xfc, 0x0, 0x3, 0xff, 0xe2, 0x0, + 0xb, 0xff, 0x40, 0x0, 0x2, 0x22, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xe0, 0x0, 0x7, 0xff, 0xe0, 0x0, + 0x7, 0xff, 0xe0, 0x0, 0x7, 0xff, 0xe0, 0x0, + 0x7, 0xff, 0xe0, 0x0, 0x7, 0xff, 0xe0, 0x0, + 0x7, 0xff, 0xe0, 0x0, 0x7, 0xff, 0xe0, 0x0, + 0x7, 0xff, 0xe0, 0x0, 0x7, 0xff, 0xe0, 0x0, + 0x7, 0xff, 0xe0, 0x0, 0x7, 0xff, 0xe0, 0x0, + 0x7, 0xff, 0xe0, 0x0, 0x7, 0xff, 0xe0, 0x0, + 0x7, 0xff, 0xe0, 0x0, 0x7, 0xff, 0xe0, 0x0, + 0x7, 0xff, 0xe0, 0x0, 0x7, 0xff, 0xe0, 0x0, + 0x7, 0xff, 0xe0, 0x0, 0x7, 0xff, 0xe0, 0x0, + + /* U+03B0 "ΰ" */ + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf9, 0x0, 0x0, + 0x0, 0x28, 0x87, 0x0, 0x3f, 0xfd, 0x8, 0x88, + 0x10, 0x5, 0xff, 0xe0, 0xb, 0xff, 0x20, 0xff, + 0xf2, 0x0, 0x5f, 0xfe, 0x2, 0xff, 0x60, 0xf, + 0xff, 0x20, 0x5, 0xff, 0xe0, 0xaf, 0xa0, 0x0, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0x47, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xf4, 0x7f, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x47, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf4, 0x7f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x47, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf4, 0x7f, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x47, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf4, + 0x7f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0x47, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf4, 0x7f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x47, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf4, 0x7f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x35, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf2, 0x3f, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x8f, 0xfe, 0x0, 0xef, 0xfd, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xa0, 0x7, 0xff, 0xfc, 0x20, + 0x0, 0x4e, 0xff, 0xf2, 0x0, 0xb, 0xff, 0xff, + 0xdc, 0xef, 0xff, 0xf7, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x3, + 0x9d, 0xff, 0xec, 0x71, 0x0, 0x0, + + /* U+03B1 "α" */ + 0x0, 0x0, 0x6, 0xbe, 0xfe, 0xc7, 0x10, 0x0, + 0xff, 0xf6, 0x0, 0x3, 0xef, 0xff, 0xff, 0xff, + 0xe3, 0x4, 0xff, 0xf1, 0x0, 0x4f, 0xff, 0xff, + 0xdc, 0xef, 0xff, 0x39, 0xff, 0xd0, 0x1, 0xef, + 0xff, 0x91, 0x0, 0x5, 0xef, 0xdd, 0xff, 0x90, + 0x9, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0x40, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0x10, 0x4f, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x7f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfa, 0x0, + 0x9f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xf6, 0x0, 0xaf, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xf3, 0x0, 0xaf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xf3, 0x0, 0x8f, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf6, 0x0, + 0x7f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xf9, 0x0, 0x3f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xfd, 0x0, 0xe, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0x0, 0x8, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x40, + 0x0, 0xef, 0xff, 0x70, 0x0, 0x7, 0xff, 0xbd, + 0xff, 0x70, 0x0, 0x3f, 0xff, 0xff, 0xcc, 0xff, + 0xff, 0x39, 0xff, 0xb0, 0x0, 0x3, 0xdf, 0xff, + 0xff, 0xff, 0xf4, 0x4, 0xff, 0xf0, 0x0, 0x0, + 0x6, 0xbe, 0xfe, 0xc7, 0x10, 0x0, 0xef, 0xf5, + + /* U+03B2 "β" */ + 0x0, 0x0, 0x6, 0xbe, 0xff, 0xea, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x5e, 0xff, 0xff, 0xff, 0xff, + 0xd2, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xfe, 0xcc, + 0xff, 0xff, 0xe1, 0x0, 0x0, 0x4f, 0xff, 0xc4, + 0x0, 0x0, 0x7f, 0xff, 0xb0, 0x0, 0xc, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x20, 0x1, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf6, + 0x0, 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0x70, 0x5, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xf5, 0x0, 0x6f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x10, 0x6, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x4e, 0xff, 0x50, 0x0, 0x6f, + 0xfe, 0x0, 0x6, 0x79, 0xdf, 0xfe, 0x40, 0x0, + 0x6, 0xff, 0xe0, 0x2, 0xff, 0xff, 0xe8, 0x0, + 0x0, 0x0, 0x6f, 0xfe, 0x0, 0x2f, 0xff, 0xff, + 0xfd, 0x70, 0x0, 0x6, 0xff, 0xe0, 0x0, 0x1, + 0x26, 0xbf, 0xff, 0xc1, 0x0, 0x6f, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xb0, 0x6, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x50, + 0x6f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xfc, 0x6, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf0, 0x6f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x16, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf1, 0x6f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x6, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xb0, 0x6f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf4, 0x6, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x4, 0xff, 0xfc, 0x0, 0x6f, 0xfe, 0xaf, 0xfd, + 0x87, 0x8c, 0xff, 0xfe, 0x20, 0x6, 0xff, 0xe0, + 0x9f, 0xff, 0xff, 0xff, 0xfd, 0x20, 0x0, 0x6f, + 0xfe, 0x0, 0x39, 0xdf, 0xfe, 0xa5, 0x0, 0x0, + 0x6, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+03B3 "γ" */ + 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x50, 0xef, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xe0, 0x9, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xf9, 0x0, 0x3f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x30, 0x0, 0xdf, + 0xf9, 0x0, 0x0, 0x0, 0x8, 0xff, 0xd0, 0x0, + 0x7, 0xff, 0xe0, 0x0, 0x0, 0x0, 0xef, 0xf7, + 0x0, 0x0, 0x1f, 0xff, 0x40, 0x0, 0x0, 0x4f, + 0xff, 0x10, 0x0, 0x0, 0xbf, 0xfa, 0x0, 0x0, + 0xa, 0xff, 0xb0, 0x0, 0x0, 0x5, 0xff, 0xf0, + 0x0, 0x0, 0xff, 0xf5, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x50, 0x0, 0x5f, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xfb, 0x0, 0xb, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf1, 0x1, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0x70, 0x7f, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfc, + 0xd, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xf5, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, + + /* U+03B4 "δ" */ + 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf1, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x10, 0x0, 0x8f, 0xff, 0xfb, 0xbb, + 0xbb, 0xbb, 0xbb, 0xb1, 0x0, 0x0, 0x5f, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2d, 0xff, 0xb1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xe3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xef, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5b, 0xef, 0xff, + 0xfc, 0x20, 0x0, 0x0, 0x0, 0x2, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x3, 0xef, + 0xff, 0xe9, 0x89, 0xdf, 0xff, 0x70, 0x0, 0x1, + 0xef, 0xff, 0x70, 0x0, 0x0, 0x5f, 0xff, 0x70, + 0x0, 0x8f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x40, 0xf, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xfd, 0x4, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xf4, 0x7f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0x89, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfb, + 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xc9, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xfc, 0x8f, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xb5, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xf9, 0x2f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x50, + 0xcf, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf1, 0x4, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf9, 0x0, 0xa, 0xff, 0xfb, 0x20, 0x0, + 0x19, 0xff, 0xfe, 0x10, 0x0, 0x1c, 0xff, 0xff, + 0xdb, 0xcf, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x1a, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0x10, 0x0, 0x0, + 0x0, 0x3, 0x8d, 0xef, 0xec, 0x83, 0x0, 0x0, + 0x0, + + /* U+03B5 "ε" */ + 0x0, 0x0, 0x5b, 0xef, 0xfd, 0x94, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xc2, 0x0, + 0x0, 0xaf, 0xff, 0xfe, 0xff, 0xff, 0xff, 0x10, + 0x3, 0xff, 0xf9, 0x10, 0x3, 0x9f, 0xe4, 0x0, + 0x8, 0xff, 0xd0, 0x0, 0x0, 0x2, 0x20, 0x0, + 0x9, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xfb, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xfe, 0xca, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xfd, 0x51, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0x90, 0x0, 0x0, 0x2, 0xd6, 0x0, + 0xa, 0xff, 0xf8, 0x0, 0x0, 0x6f, 0xff, 0x90, + 0x2, 0xff, 0xff, 0xfc, 0xcf, 0xff, 0xff, 0x60, + 0x0, 0x4e, 0xff, 0xff, 0xff, 0xff, 0xc3, 0x0, + 0x0, 0x1, 0x7c, 0xef, 0xed, 0x94, 0x0, 0x0, + + /* U+03B6 "ζ" */ + 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x7, 0xbb, 0xbb, 0xbb, 0xbf, 0xff, 0xd2, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xdf, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xe2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xfe, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xe2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xe5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xec, 0xa8, 0x63, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd3, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x2, 0x9d, 0xff, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x4d, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2d, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x4d, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xed, 0xa5, 0x0, 0x0, + + /* U+03B7 "η" */ + 0x6f, 0xf9, 0x0, 0x4a, 0xdf, 0xfd, 0x93, 0x0, + 0x6, 0xff, 0x91, 0xaf, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x6f, 0xf9, 0xcf, 0xff, 0xee, 0xff, 0xff, + 0xf7, 0x6, 0xff, 0xff, 0xf8, 0x10, 0x1, 0x7f, + 0xff, 0xf1, 0x6f, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x46, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xf7, 0x6f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0xd, 0xff, 0x86, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xf9, 0x6f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0x96, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xf9, 0x6f, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0x96, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf9, 0x6f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x96, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf9, 0x6f, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x96, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf9, + 0x6f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0x96, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xf9, 0x6f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0x96, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0x90, + + /* U+03B8 "θ" */ + 0x0, 0x0, 0x1, 0x7c, 0xef, 0xec, 0x72, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xef, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xec, + 0xdf, 0xff, 0xf7, 0x0, 0x0, 0x2, 0xff, 0xfd, + 0x30, 0x0, 0x3c, 0xff, 0xf4, 0x0, 0x0, 0xaf, + 0xfe, 0x10, 0x0, 0x0, 0xc, 0xff, 0xc0, 0x0, + 0x1f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0x40, 0x6, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xf9, 0x0, 0xbf, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xd0, 0xe, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x0, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf2, 0x2f, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0x53, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf5, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x64, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf7, 0x4f, 0xff, 0xba, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaf, 0xff, 0x63, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf5, + 0x2f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x50, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf2, 0xe, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x0, 0xbf, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xd0, 0x6, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf9, 0x0, + 0x1f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x40, 0x0, 0xaf, 0xfe, 0x10, 0x0, 0x0, 0xd, + 0xff, 0xc0, 0x0, 0x2, 0xff, 0xfd, 0x30, 0x0, + 0x2c, 0xff, 0xf4, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xdb, 0xdf, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x5, + 0xef, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x7c, 0xef, 0xec, 0x72, 0x0, 0x0, + 0x0, + + /* U+03B9 "ι" */ + 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, + 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, + 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, + 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, + 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, + + /* U+03BA "κ" */ + 0x8f, 0xfd, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfa, + 0x8, 0xff, 0xd0, 0x0, 0x0, 0xb, 0xff, 0xf9, + 0x0, 0x8f, 0xfd, 0x0, 0x0, 0xb, 0xff, 0xf9, + 0x0, 0x8, 0xff, 0xd0, 0x0, 0xb, 0xff, 0xf8, + 0x0, 0x0, 0x8f, 0xfd, 0x0, 0xb, 0xff, 0xf7, + 0x0, 0x0, 0x8, 0xff, 0xd0, 0xb, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x8f, 0xfd, 0xc, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xdc, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xee, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x8, 0xff, 0xe2, + 0x3f, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x8f, 0xfd, + 0x0, 0x6f, 0xff, 0xc0, 0x0, 0x0, 0x8, 0xff, + 0xd0, 0x0, 0x9f, 0xff, 0xa0, 0x0, 0x0, 0x8f, + 0xfd, 0x0, 0x0, 0xcf, 0xff, 0x70, 0x0, 0x8, + 0xff, 0xd0, 0x0, 0x1, 0xdf, 0xff, 0x40, 0x0, + 0x8f, 0xfd, 0x0, 0x0, 0x2, 0xff, 0xff, 0x20, + 0x8, 0xff, 0xd0, 0x0, 0x0, 0x5, 0xff, 0xfd, + 0x10, 0x8f, 0xfd, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xfb, 0x8, 0xff, 0xd0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf9, + + /* U+03BB "λ" */ + 0x0, 0x0, 0xf, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfd, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x2f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xa0, 0xbf, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf4, 0x5, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xfe, 0x0, 0xe, 0xff, 0x80, + 0x0, 0x0, 0x0, 0xe, 0xff, 0x80, 0x0, 0x9f, + 0xfe, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf2, 0x0, + 0x3, 0xff, 0xf4, 0x0, 0x0, 0x0, 0xbf, 0xfc, + 0x0, 0x0, 0xd, 0xff, 0xb0, 0x0, 0x0, 0x1f, + 0xff, 0x60, 0x0, 0x0, 0x7f, 0xff, 0x10, 0x0, + 0x7, 0xff, 0xf1, 0x0, 0x0, 0x1, 0xff, 0xf7, + 0x0, 0x0, 0xdf, 0xfa, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xd0, 0x0, 0x3f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x30, 0x9, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xf9, 0x0, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xe0, 0x5f, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0x50, + + /* U+03BC "μ" */ + 0x6f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0x86, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xf8, 0x6f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0x86, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xf8, 0x6f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0x86, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xf8, 0x6f, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0x86, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xf8, 0x6f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0x86, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xf8, 0x6f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0x86, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf8, 0x6f, 0xff, + 0x10, 0x0, 0x0, 0x0, 0xe, 0xff, 0x86, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf8, 0x6f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x86, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x3f, 0xff, 0xf8, + 0x6f, 0xff, 0xff, 0x71, 0x2, 0x8f, 0xff, 0xff, + 0x86, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, + 0xf8, 0x6f, 0xfe, 0x5f, 0xff, 0xff, 0xff, 0x77, + 0xff, 0x86, 0xff, 0xe0, 0x29, 0xef, 0xea, 0x40, + 0x7f, 0xf8, 0x6f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03BD "ν" */ + 0x5f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x50, 0xef, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xf0, 0x9, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xfa, 0x0, 0x3f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x40, 0x0, 0xdf, + 0xf9, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd0, 0x0, + 0x7, 0xff, 0xe0, 0x0, 0x0, 0x0, 0xdf, 0xf8, + 0x0, 0x0, 0x1f, 0xff, 0x40, 0x0, 0x0, 0x3f, + 0xff, 0x20, 0x0, 0x0, 0xbf, 0xfa, 0x0, 0x0, + 0x9, 0xff, 0xc0, 0x0, 0x0, 0x5, 0xff, 0xf0, + 0x0, 0x0, 0xef, 0xf6, 0x0, 0x0, 0x0, 0xe, + 0xff, 0x50, 0x0, 0x4f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xfb, 0x0, 0xa, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf1, 0x0, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0x60, 0x5f, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfb, + 0xb, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xf1, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xbf, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x40, 0x0, 0x0, 0x0, + + /* U+03BE "ξ" */ + 0x0, 0x0, 0x4, 0x9c, 0xef, 0xff, 0xf5, 0x0, + 0x0, 0x2, 0xcf, 0xff, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xdc, 0xcc, 0xc3, 0x0, + 0x0, 0xdf, 0xfe, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0x83, 0x10, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x5a, 0xef, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x6, 0xef, 0xff, 0xfd, 0xc1, 0x0, + 0x0, 0x1, 0xcf, 0xff, 0x94, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0x93, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xfd, 0xb7, 0x20, 0x0, + 0x0, 0x5, 0xef, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x6, 0xbf, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x14, 0x8f, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x6e, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xfe, 0x20, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xd2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xed, 0xa5, 0x0, 0x0, + + /* U+03BF "ο" */ + 0x0, 0x0, 0x2, 0x8c, 0xef, 0xed, 0x93, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, + 0xfb, 0x10, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xdc, + 0xdf, 0xff, 0xfe, 0x20, 0x0, 0xd, 0xff, 0xfa, + 0x20, 0x0, 0x19, 0xff, 0xfd, 0x0, 0x7, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf9, 0x0, + 0xef, 0xfc, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf1, 0x3f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x57, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xf9, 0x8f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xb9, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfc, 0xaf, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xb8, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xfa, 0x7f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0x83, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf5, 0xe, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x10, 0x7f, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x90, + 0x0, 0xdf, 0xff, 0xa1, 0x0, 0x1, 0x8f, 0xff, + 0xe1, 0x0, 0x2, 0xdf, 0xff, 0xfd, 0xbc, 0xff, + 0xff, 0xe3, 0x0, 0x0, 0x1, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xb1, 0x0, 0x0, 0x0, 0x0, 0x28, + 0xce, 0xfe, 0xd9, 0x30, 0x0, 0x0, + + /* U+03C0 "π" */ + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf6, 0x2f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x1b, 0xbb, 0xbb, 0xff, 0xfc, 0xbb, + 0xbb, 0xbb, 0xbd, 0xff, 0xfb, 0xbb, 0xb4, 0x0, + 0x0, 0x0, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x6, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x6, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x6, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x6, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xe0, 0x0, 0x0, + + /* U+03C1 "ρ" */ + 0x0, 0x0, 0x5, 0xad, 0xff, 0xdb, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x3d, 0xff, 0xff, 0xff, 0xff, + 0xe5, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xdc, + 0xef, 0xff, 0xf7, 0x0, 0x0, 0xe, 0xff, 0xf7, + 0x0, 0x0, 0x4d, 0xff, 0xf4, 0x0, 0x7, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x1c, 0xff, 0xe0, 0x0, + 0xdf, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x60, 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xfc, 0x4, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xf0, 0x7f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x28, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf3, 0x8f, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x39, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf2, 0x9f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0x9, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xc0, 0x9f, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf7, 0x9, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x10, + 0x9f, 0xff, 0xff, 0x60, 0x0, 0x3, 0xcf, 0xff, + 0x60, 0x9, 0xff, 0xff, 0xff, 0xfc, 0xce, 0xff, + 0xff, 0x90, 0x0, 0x9f, 0xfc, 0x5f, 0xff, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x9, 0xff, 0xc0, 0x17, + 0xce, 0xfe, 0xc7, 0x10, 0x0, 0x0, 0x9f, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+03C2 "ς" */ + 0x0, 0x0, 0x0, 0x2, 0x7b, 0xde, 0xfe, 0xda, + 0x60, 0x0, 0x0, 0x2b, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xdc, 0xcd, + 0xff, 0x60, 0x0, 0x7f, 0xff, 0xd6, 0x10, 0x0, + 0x0, 0x31, 0x0, 0x5f, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xfb, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xfe, 0x82, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xfd, 0x84, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xef, 0xff, 0xff, 0xfe, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x5a, 0xef, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x26, 0xcf, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x31, + 0x25, 0xdf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0xb1, 0x0, 0x0, 0x0, 0x0, + 0xbe, 0xff, 0xda, 0x40, 0x0, 0x0, + + /* U+03C3 "σ" */ + 0x0, 0x0, 0x2, 0x8c, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfa, 0x0, 0x1, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x2e, + 0xff, 0xff, 0xdc, 0xdf, 0xff, 0xff, 0xcb, 0xbb, + 0xb6, 0x1, 0xdf, 0xff, 0x91, 0x0, 0x1, 0x8f, + 0xff, 0xd1, 0x0, 0x0, 0x8, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xf9, 0x0, 0x0, 0xf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x10, 0x0, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x50, 0x0, 0x8f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x80, 0x0, + 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xa0, 0x0, 0xbf, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xb0, 0x0, 0xbf, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xa0, + 0x0, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0x90, 0x0, 0x8f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x70, 0x0, 0x4f, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0x30, 0x0, 0xf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xfe, 0x0, 0x0, 0x8, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf7, 0x0, 0x0, + 0x1, 0xdf, 0xff, 0x81, 0x0, 0x1, 0x9f, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, 0xdb, + 0xdf, 0xff, 0xfd, 0x20, 0x0, 0x0, 0x0, 0x1, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0x8c, 0xef, 0xec, 0x82, + 0x0, 0x0, 0x0, 0x0, + + /* U+03C4 "τ" */ + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x22, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x1b, + 0xbb, 0xbb, 0xff, 0xfc, 0xbb, 0xbb, 0x10, 0x0, + 0x0, 0xf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0x60, 0x0, 0x0, + + /* U+03C5 "υ" */ + 0x7f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0x47, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf4, 0x7f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x47, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf4, 0x7f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0x47, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf4, 0x7f, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0x47, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf4, 0x7f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0x47, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xf4, 0x7f, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x47, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf4, 0x7f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x35, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf2, 0x3f, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x8f, 0xfe, 0x0, + 0xef, 0xfd, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xa0, + 0x7, 0xff, 0xfc, 0x20, 0x0, 0x4e, 0xff, 0xf2, + 0x0, 0xb, 0xff, 0xff, 0xdc, 0xef, 0xff, 0xf7, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x3, 0x9d, 0xff, 0xec, 0x71, + 0x0, 0x0, + + /* U+03C6 "φ" */ + 0x0, 0x0, 0x6, 0xbe, 0x20, 0x6, 0xcf, 0xfe, + 0xb5, 0x0, 0x0, 0x0, 0x0, 0x2d, 0xff, 0xe0, + 0x7, 0xff, 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, + 0x2e, 0xff, 0xfa, 0x0, 0xef, 0xff, 0xdd, 0xff, + 0xfd, 0x10, 0x0, 0xd, 0xff, 0xe5, 0x0, 0x1f, + 0xff, 0x90, 0x4, 0xef, 0xfa, 0x0, 0x8, 0xff, + 0xf3, 0x0, 0x2, 0xff, 0xf3, 0x0, 0x3, 0xff, + 0xf3, 0x0, 0xef, 0xf8, 0x0, 0x0, 0x3f, 0xff, + 0x20, 0x0, 0xb, 0xff, 0xa0, 0x4f, 0xff, 0x20, + 0x0, 0x3, 0xff, 0xf1, 0x0, 0x0, 0x6f, 0xff, + 0x7, 0xff, 0xe0, 0x0, 0x0, 0x3f, 0xff, 0x10, + 0x0, 0x4, 0xff, 0xf2, 0x9f, 0xfc, 0x0, 0x0, + 0x3, 0xff, 0xf1, 0x0, 0x0, 0x3f, 0xff, 0x4a, + 0xff, 0xc0, 0x0, 0x0, 0x3f, 0xff, 0x10, 0x0, + 0x3, 0xff, 0xf4, 0x9f, 0xfd, 0x0, 0x0, 0x3, + 0xff, 0xf1, 0x0, 0x0, 0x4f, 0xff, 0x27, 0xff, + 0xf0, 0x0, 0x0, 0x3f, 0xff, 0x10, 0x0, 0x7, + 0xff, 0xf0, 0x4f, 0xff, 0x50, 0x0, 0x3, 0xff, + 0xf1, 0x0, 0x0, 0xcf, 0xfb, 0x0, 0xff, 0xfc, + 0x0, 0x0, 0x3f, 0xff, 0x10, 0x0, 0x3f, 0xff, + 0x60, 0x8, 0xff, 0xf6, 0x0, 0x3, 0xff, 0xf1, + 0x0, 0xd, 0xff, 0xe0, 0x0, 0xe, 0xff, 0xf5, + 0x0, 0x3f, 0xff, 0x10, 0x1c, 0xff, 0xf4, 0x0, + 0x0, 0x2f, 0xff, 0xfa, 0x33, 0xff, 0xf2, 0x6e, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x3e, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x2b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x9d, 0xff, + 0xff, 0xea, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03C7 "χ" */ + 0xd, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xe0, 0x5, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0x60, 0x0, 0xcf, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xfd, 0x0, 0x0, 0x4f, + 0xff, 0x40, 0x0, 0x0, 0x4, 0xff, 0xf5, 0x0, + 0x0, 0xc, 0xff, 0xc0, 0x0, 0x0, 0xc, 0xff, + 0xc0, 0x0, 0x0, 0x3, 0xff, 0xf4, 0x0, 0x0, + 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0xbf, 0xfc, + 0x0, 0x0, 0xcf, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x40, 0x5, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xc0, 0xd, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf4, 0x5f, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xfc, 0xdf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xf8, 0xaf, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf1, 0x2f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0x80, 0x9, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfe, 0x0, 0x1, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xf7, 0x0, 0x0, 0x9f, 0xfe, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xe0, 0x0, 0x0, + 0x1f, 0xff, 0x80, 0x0, 0x0, 0x2f, 0xff, 0x60, + 0x0, 0x0, 0x8, 0xff, 0xf1, 0x0, 0x0, 0xbf, + 0xfd, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfa, 0x0, + 0x4, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0x30, 0xd, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xc0, 0x6f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf5, + + /* U+03C8 "ψ" */ + 0xbf, 0xf9, 0x0, 0x0, 0x2, 0xff, 0xf3, 0x0, + 0x0, 0x8, 0xff, 0xdb, 0xff, 0x90, 0x0, 0x0, + 0x2f, 0xff, 0x30, 0x0, 0x0, 0x8f, 0xfd, 0xbf, + 0xf9, 0x0, 0x0, 0x2, 0xff, 0xf3, 0x0, 0x0, + 0x8, 0xff, 0xdb, 0xff, 0x90, 0x0, 0x0, 0x2f, + 0xff, 0x30, 0x0, 0x0, 0x8f, 0xfd, 0xbf, 0xf9, + 0x0, 0x0, 0x2, 0xff, 0xf3, 0x0, 0x0, 0x8, + 0xff, 0xdb, 0xff, 0x90, 0x0, 0x0, 0x2f, 0xff, + 0x30, 0x0, 0x0, 0x8f, 0xfd, 0xbf, 0xf9, 0x0, + 0x0, 0x2, 0xff, 0xf3, 0x0, 0x0, 0x8, 0xff, + 0xdb, 0xff, 0x90, 0x0, 0x0, 0x2f, 0xff, 0x30, + 0x0, 0x0, 0x8f, 0xfd, 0xbf, 0xf9, 0x0, 0x0, + 0x2, 0xff, 0xf3, 0x0, 0x0, 0x8, 0xff, 0xdb, + 0xff, 0x90, 0x0, 0x0, 0x2f, 0xff, 0x30, 0x0, + 0x0, 0x8f, 0xfc, 0xbf, 0xf9, 0x0, 0x0, 0x2, + 0xff, 0xf3, 0x0, 0x0, 0x8, 0xff, 0xcb, 0xff, + 0xa0, 0x0, 0x0, 0x2f, 0xff, 0x30, 0x0, 0x0, + 0x9f, 0xfc, 0x9f, 0xfb, 0x0, 0x0, 0x2, 0xff, + 0xf3, 0x0, 0x0, 0xb, 0xff, 0xa8, 0xff, 0xe0, + 0x0, 0x0, 0x2f, 0xff, 0x30, 0x0, 0x0, 0xef, + 0xf8, 0x4f, 0xff, 0x50, 0x0, 0x2, 0xff, 0xf3, + 0x0, 0x0, 0x4f, 0xff, 0x50, 0xdf, 0xfe, 0x20, + 0x0, 0x2f, 0xff, 0x30, 0x0, 0x2e, 0xff, 0xf0, + 0x4, 0xff, 0xfe, 0x61, 0x2, 0xff, 0xf3, 0x1, + 0x7e, 0xff, 0xf7, 0x0, 0x6, 0xff, 0xff, 0xfe, + 0xdf, 0xff, 0xde, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x4, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe6, 0x0, 0x0, 0x0, 0x0, 0x59, 0xde, 0xff, + 0xff, 0xff, 0xda, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03C9 "ω" */ + 0x0, 0xb, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0x50, 0x0, 0x0, 0x3f, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xd0, 0x0, 0x0, 0xbf, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xf5, 0x0, 0x1, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfb, 0x0, + 0x7, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x11, 0x10, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x10, 0xb, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0xdf, 0xf8, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x60, 0xf, 0xff, 0x80, 0x0, + 0x0, 0x0, 0xdf, 0xf8, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xa0, 0x2f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0xdf, 0xf8, 0x0, 0x0, 0x0, 0xa, 0xff, 0xd0, + 0x4f, 0xff, 0x20, 0x0, 0x0, 0x0, 0xdf, 0xf8, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf0, 0x5f, 0xff, + 0x10, 0x0, 0x0, 0x0, 0xdf, 0xf8, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xf0, 0x5f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf8, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf0, 0x5f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0xdf, 0xf8, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf0, + 0x3f, 0xff, 0x30, 0x0, 0x0, 0x0, 0xef, 0xf9, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xe0, 0xf, 0xff, + 0x60, 0x0, 0x0, 0x0, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xb0, 0xc, 0xff, 0xc0, 0x0, + 0x0, 0x4, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x70, 0x6, 0xff, 0xf4, 0x0, 0x0, 0xc, + 0xfe, 0xff, 0x60, 0x0, 0x0, 0x9f, 0xff, 0x10, + 0x0, 0xef, 0xfe, 0x20, 0x0, 0xaf, 0xf6, 0xbf, + 0xf5, 0x0, 0x6, 0xff, 0xfa, 0x0, 0x0, 0x4f, + 0xff, 0xfb, 0xae, 0xff, 0xc0, 0x2f, 0xff, 0xca, + 0xcf, 0xff, 0xd1, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xfc, 0x10, 0x4, 0xff, 0xff, 0xff, 0xfd, + 0x10, 0x0, 0x0, 0x0, 0x29, 0xdf, 0xfc, 0x60, + 0x0, 0x0, 0x19, 0xdf, 0xec, 0x60, 0x0, 0x0, + + /* U+03CA "ϊ" */ + 0xf, 0xff, 0x70, 0x1, 0xff, 0xf6, 0xf, 0xff, + 0x70, 0x1, 0xff, 0xf6, 0xf, 0xff, 0x70, 0x1, + 0xff, 0xf6, 0xc, 0xcc, 0x50, 0x1, 0xcc, 0xc4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfe, + 0x0, 0x0, + + /* U+03CB "ϋ" */ + 0x0, 0xc, 0xff, 0xb0, 0x0, 0xef, 0xf9, 0x0, + 0x0, 0x0, 0xcf, 0xfb, 0x0, 0xe, 0xff, 0x90, + 0x0, 0x0, 0xc, 0xff, 0xb0, 0x0, 0xef, 0xf9, + 0x0, 0x0, 0x0, 0x9c, 0xc8, 0x0, 0xb, 0xcc, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf4, 0x7f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0x47, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xf4, 0x7f, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x47, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf4, 0x7f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x47, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf4, 0x7f, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x47, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf4, + 0x7f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0x47, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf4, 0x7f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x47, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xf3, 0x5f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x23, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xe0, 0xe, 0xff, 0xd0, 0x0, 0x0, + 0x2, 0xff, 0xfa, 0x0, 0x7f, 0xff, 0xc2, 0x0, + 0x4, 0xef, 0xff, 0x20, 0x0, 0xbf, 0xff, 0xfd, + 0xce, 0xff, 0xff, 0x70, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x39, + 0xdf, 0xfe, 0xc7, 0x10, 0x0, 0x0, + + /* U+03CC "ό" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x22, 0x22, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x28, 0xce, 0xfe, 0xd9, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xb1, 0x0, + 0x0, 0x1, 0xdf, 0xff, 0xfd, 0xcd, 0xff, 0xff, + 0xe2, 0x0, 0x0, 0xdf, 0xff, 0xa2, 0x0, 0x1, + 0x9f, 0xff, 0xd0, 0x0, 0x7f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x90, 0xe, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x13, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf5, + 0x7f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0x98, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xfb, 0x9f, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xca, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfb, 0x8f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xa7, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xf8, 0x3f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x50, 0xef, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf1, 0x7, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xf9, 0x0, 0xd, 0xff, + 0xfa, 0x10, 0x0, 0x18, 0xff, 0xfe, 0x10, 0x0, + 0x2d, 0xff, 0xff, 0xdb, 0xcf, 0xff, 0xfe, 0x30, + 0x0, 0x0, 0x1a, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0x10, 0x0, 0x0, 0x0, 0x2, 0x8c, 0xef, 0xed, + 0x93, 0x0, 0x0, 0x0, + + /* U+03CD "ύ" */ + 0x0, 0x0, 0x0, 0x0, 0x2, 0x22, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfd, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xf4, 0x7f, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x47, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf4, 0x7f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x47, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf4, 0x7f, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x47, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf4, + 0x7f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0x47, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf4, 0x7f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x47, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf4, 0x7f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0x47, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xf3, 0x5f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0x23, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xe0, 0xe, 0xff, 0xd0, 0x0, + 0x0, 0x2, 0xff, 0xfa, 0x0, 0x7f, 0xff, 0xc2, + 0x0, 0x4, 0xef, 0xff, 0x20, 0x0, 0xbf, 0xff, + 0xfd, 0xce, 0xff, 0xff, 0x70, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x39, 0xdf, 0xfe, 0xc7, 0x10, 0x0, 0x0, + + /* U+03CE "ώ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x22, + 0x22, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0x50, 0x0, 0x0, 0x3f, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xd0, 0x0, 0x0, 0xbf, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf5, 0x0, + 0x1, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xfb, 0x0, 0x7, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x11, 0x10, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0x10, 0xb, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0xdf, 0xf8, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x60, 0xf, 0xff, 0x80, 0x0, 0x0, 0x0, + 0xdf, 0xf8, 0x0, 0x0, 0x0, 0xd, 0xff, 0xa0, + 0x2f, 0xff, 0x40, 0x0, 0x0, 0x0, 0xdf, 0xf8, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xd0, 0x4f, 0xff, + 0x20, 0x0, 0x0, 0x0, 0xdf, 0xf8, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf0, 0x5f, 0xff, 0x10, 0x0, + 0x0, 0x0, 0xdf, 0xf8, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf0, 0x5f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xf8, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf0, + 0x5f, 0xff, 0x10, 0x0, 0x0, 0x0, 0xdf, 0xf8, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf0, 0x3f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0xef, 0xf9, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xe0, 0xf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0xff, 0xfb, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xb0, 0xc, 0xff, 0xc0, 0x0, 0x0, 0x4, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x70, + 0x6, 0xff, 0xf4, 0x0, 0x0, 0xc, 0xfe, 0xff, + 0x60, 0x0, 0x0, 0x9f, 0xff, 0x10, 0x0, 0xef, + 0xfe, 0x20, 0x0, 0xaf, 0xf6, 0xbf, 0xf5, 0x0, + 0x6, 0xff, 0xfa, 0x0, 0x0, 0x4f, 0xff, 0xfb, + 0xae, 0xff, 0xc0, 0x2f, 0xff, 0xca, 0xcf, 0xff, + 0xd1, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xfc, + 0x10, 0x4, 0xff, 0xff, 0xff, 0xfd, 0x10, 0x0, + 0x0, 0x0, 0x29, 0xdf, 0xfc, 0x60, 0x0, 0x0, + 0x19, 0xdf, 0xec, 0x60, 0x0, 0x0, + + /* U+03F4 "ϴ" */ + 0x0, 0x0, 0x0, 0xc, 0xff, 0x80, 0x0, 0x3, + 0x88, 0x60, 0x4, 0xff, 0xc1, 0x88, 0x80, 0x6f, + 0xfc, 0x0, 0xcf, 0xe1, 0x2f, 0xff, 0x16, 0xff, + 0xc0, 0x4f, 0xf4, 0x2, 0xff, 0xf1, 0x6f, 0xfc, + 0xb, 0xf8, 0x0, 0x2f, 0xff, 0x10 +}; + + +/*--------------------- + * GLYPH DESCRIPTION + *--------------------*/ + +static const lv_font_fmt_txt_glyph_dsc_t glyph_dsc[] = { + {.bitmap_index = 0, .adv_w = 0, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0} /* id = 0 reserved */, + {.bitmap_index = 0, .adv_w = 169, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 0, .adv_w = 170, .box_w = 5, .box_h = 27, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 68, .adv_w = 216, .box_w = 11, .box_h = 10, .ofs_x = 1, .ofs_y = 17}, + {.bitmap_index = 123, .adv_w = 338, .box_w = 21, .box_h = 27, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 407, .adv_w = 338, .box_w = 19, .box_h = 34, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 730, .adv_w = 541, .box_w = 30, .box_h = 29, .ofs_x = 2, .ofs_y = -2}, + {.bitmap_index = 1165, .adv_w = 406, .box_w = 24, .box_h = 28, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 1501, .adv_w = 115, .box_w = 5, .box_h = 10, .ofs_x = 1, .ofs_y = 17}, + {.bitmap_index = 1526, .adv_w = 203, .box_w = 10, .box_h = 34, .ofs_x = 2, .ofs_y = -7}, + {.bitmap_index = 1696, .adv_w = 203, .box_w = 10, .box_h = 34, .ofs_x = 1, .ofs_y = -7}, + {.bitmap_index = 1866, .adv_w = 236, .box_w = 13, .box_h = 12, .ofs_x = 1, .ofs_y = 15}, + {.bitmap_index = 1944, .adv_w = 355, .box_w = 19, .box_h = 18, .ofs_x = 2, .ofs_y = 4}, + {.bitmap_index = 2115, .adv_w = 170, .box_w = 5, .box_h = 10, .ofs_x = 3, .ofs_y = -6}, + {.bitmap_index = 2140, .adv_w = 202, .box_w = 11, .box_h = 4, .ofs_x = 1, .ofs_y = 8}, + {.bitmap_index = 2162, .adv_w = 170, .box_w = 5, .box_h = 4, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 2172, .adv_w = 169, .box_w = 11, .box_h = 27, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2321, .adv_w = 338, .box_w = 19, .box_h = 27, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2578, .adv_w = 338, .box_w = 11, .box_h = 27, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 2727, .adv_w = 338, .box_w = 19, .box_h = 27, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2984, .adv_w = 338, .box_w = 19, .box_h = 27, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3241, .adv_w = 338, .box_w = 20, .box_h = 27, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3511, .adv_w = 338, .box_w = 19, .box_h = 27, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3768, .adv_w = 338, .box_w = 19, .box_h = 27, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4025, .adv_w = 338, .box_w = 19, .box_h = 27, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4282, .adv_w = 338, .box_w = 19, .box_h = 27, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4539, .adv_w = 338, .box_w = 19, .box_h = 27, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4796, .adv_w = 170, .box_w = 5, .box_h = 20, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 4846, .adv_w = 170, .box_w = 5, .box_h = 26, .ofs_x = 3, .ofs_y = -6}, + {.bitmap_index = 4911, .adv_w = 355, .box_w = 19, .box_h = 19, .ofs_x = 2, .ofs_y = 4}, + {.bitmap_index = 5092, .adv_w = 355, .box_w = 19, .box_h = 12, .ofs_x = 2, .ofs_y = 8}, + {.bitmap_index = 5206, .adv_w = 355, .box_w = 19, .box_h = 19, .ofs_x = 2, .ofs_y = 4}, + {.bitmap_index = 5387, .adv_w = 338, .box_w = 19, .box_h = 27, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 5644, .adv_w = 617, .box_w = 36, .box_h = 34, .ofs_x = 2, .ofs_y = -7}, + {.bitmap_index = 6256, .adv_w = 406, .box_w = 27, .box_h = 27, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 6621, .adv_w = 406, .box_w = 22, .box_h = 27, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 6918, .adv_w = 439, .box_w = 25, .box_h = 27, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 7256, .adv_w = 439, .box_w = 24, .box_h = 27, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 7580, .adv_w = 406, .box_w = 21, .box_h = 27, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 7864, .adv_w = 372, .box_w = 19, .box_h = 27, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 8121, .adv_w = 473, .box_w = 27, .box_h = 27, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 8486, .adv_w = 439, .box_w = 22, .box_h = 27, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 8783, .adv_w = 170, .box_w = 5, .box_h = 27, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 8851, .adv_w = 304, .box_w = 16, .box_h = 27, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 9067, .adv_w = 406, .box_w = 24, .box_h = 27, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 9391, .adv_w = 338, .box_w = 18, .box_h = 27, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 9634, .adv_w = 506, .box_w = 27, .box_h = 27, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 9999, .adv_w = 439, .box_w = 22, .box_h = 27, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 10296, .adv_w = 473, .box_w = 27, .box_h = 27, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 10661, .adv_w = 406, .box_w = 22, .box_h = 27, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 10958, .adv_w = 473, .box_w = 28, .box_h = 29, .ofs_x = 1, .ofs_y = -2}, + {.bitmap_index = 11364, .adv_w = 439, .box_w = 25, .box_h = 27, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 11702, .adv_w = 406, .box_w = 23, .box_h = 27, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 12013, .adv_w = 372, .box_w = 23, .box_h = 27, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 12324, .adv_w = 439, .box_w = 22, .box_h = 27, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 12621, .adv_w = 406, .box_w = 26, .box_h = 27, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 12972, .adv_w = 574, .box_w = 36, .box_h = 27, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 13458, .adv_w = 406, .box_w = 26, .box_h = 27, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 13809, .adv_w = 406, .box_w = 26, .box_h = 27, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 14160, .adv_w = 372, .box_w = 23, .box_h = 27, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 14471, .adv_w = 170, .box_w = 8, .box_h = 34, .ofs_x = 2, .ofs_y = -7}, + {.bitmap_index = 14607, .adv_w = 169, .box_w = 11, .box_h = 27, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 14756, .adv_w = 170, .box_w = 9, .box_h = 34, .ofs_x = 0, .ofs_y = -7}, + {.bitmap_index = 14909, .adv_w = 285, .box_w = 16, .box_h = 15, .ofs_x = 1, .ofs_y = 13}, + {.bitmap_index = 15029, .adv_w = 338, .box_w = 23, .box_h = 3, .ofs_x = -1, .ofs_y = -7}, + {.bitmap_index = 15064, .adv_w = 202, .box_w = 8, .box_h = 6, .ofs_x = 1, .ofs_y = 22}, + {.bitmap_index = 15088, .adv_w = 338, .box_w = 19, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 15278, .adv_w = 338, .box_w = 18, .box_h = 27, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 15521, .adv_w = 304, .box_w = 18, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 15701, .adv_w = 338, .box_w = 18, .box_h = 27, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 15944, .adv_w = 338, .box_w = 19, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 16134, .adv_w = 170, .box_w = 12, .box_h = 27, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 16296, .adv_w = 338, .box_w = 18, .box_h = 27, .ofs_x = 1, .ofs_y = -7}, + {.bitmap_index = 16539, .adv_w = 338, .box_w = 17, .box_h = 27, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 16769, .adv_w = 135, .box_w = 4, .box_h = 27, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 16823, .adv_w = 135, .box_w = 8, .box_h = 34, .ofs_x = -2, .ofs_y = -7}, + {.bitmap_index = 16959, .adv_w = 304, .box_w = 17, .box_h = 27, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 17189, .adv_w = 135, .box_w = 4, .box_h = 27, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 17243, .adv_w = 506, .box_w = 28, .box_h = 20, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 17523, .adv_w = 338, .box_w = 17, .box_h = 20, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 17693, .adv_w = 338, .box_w = 19, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 17883, .adv_w = 338, .box_w = 18, .box_h = 27, .ofs_x = 2, .ofs_y = -7}, + {.bitmap_index = 18126, .adv_w = 338, .box_w = 18, .box_h = 27, .ofs_x = 1, .ofs_y = -7}, + {.bitmap_index = 18369, .adv_w = 203, .box_w = 12, .box_h = 20, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 18489, .adv_w = 304, .box_w = 17, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 18659, .adv_w = 170, .box_w = 11, .box_h = 27, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 18808, .adv_w = 338, .box_w = 17, .box_h = 20, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 18978, .adv_w = 304, .box_w = 19, .box_h = 20, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 19168, .adv_w = 439, .box_w = 28, .box_h = 20, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 19448, .adv_w = 304, .box_w = 19, .box_h = 20, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 19638, .adv_w = 304, .box_w = 19, .box_h = 27, .ofs_x = 0, .ofs_y = -7}, + {.bitmap_index = 19895, .adv_w = 304, .box_w = 19, .box_h = 20, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 20085, .adv_w = 203, .box_w = 11, .box_h = 34, .ofs_x = 1, .ofs_y = -7}, + {.bitmap_index = 20272, .adv_w = 158, .box_w = 4, .box_h = 34, .ofs_x = 3, .ofs_y = -7}, + {.bitmap_index = 20340, .adv_w = 203, .box_w = 12, .box_h = 34, .ofs_x = 0, .ofs_y = -7}, + {.bitmap_index = 20544, .adv_w = 355, .box_w = 20, .box_h = 8, .ofs_x = 1, .ofs_y = 9}, + {.bitmap_index = 20624, .adv_w = 169, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 20624, .adv_w = 338, .box_w = 21, .box_h = 28, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 20918, .adv_w = 338, .box_w = 19, .box_h = 20, .ofs_x = 1, .ofs_y = 4}, + {.bitmap_index = 21108, .adv_w = 338, .box_w = 22, .box_h = 27, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 21405, .adv_w = 158, .box_w = 4, .box_h = 34, .ofs_x = 3, .ofs_y = -7}, + {.bitmap_index = 21473, .adv_w = 338, .box_w = 19, .box_h = 34, .ofs_x = 1, .ofs_y = -7}, + {.bitmap_index = 21796, .adv_w = 202, .box_w = 11, .box_h = 4, .ofs_x = 1, .ofs_y = 23}, + {.bitmap_index = 21818, .adv_w = 448, .box_w = 28, .box_h = 28, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 22210, .adv_w = 228, .box_w = 14, .box_h = 14, .ofs_x = 0, .ofs_y = 14}, + {.bitmap_index = 22308, .adv_w = 338, .box_w = 17, .box_h = 17, .ofs_x = 2, .ofs_y = 1}, + {.bitmap_index = 22453, .adv_w = 355, .box_w = 19, .box_h = 12, .ofs_x = 2, .ofs_y = 8}, + {.bitmap_index = 22567, .adv_w = 202, .box_w = 11, .box_h = 4, .ofs_x = 1, .ofs_y = 8}, + {.bitmap_index = 22589, .adv_w = 448, .box_w = 28, .box_h = 28, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 22981, .adv_w = 243, .box_w = 11, .box_h = 10, .ofs_x = 2, .ofs_y = 17}, + {.bitmap_index = 23036, .adv_w = 355, .box_w = 19, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 23255, .adv_w = 202, .box_w = 12, .box_h = 14, .ofs_x = 0, .ofs_y = 14}, + {.bitmap_index = 23339, .adv_w = 202, .box_w = 12, .box_h = 14, .ofs_x = 0, .ofs_y = 14}, + {.bitmap_index = 23423, .adv_w = 338, .box_w = 17, .box_h = 27, .ofs_x = 2, .ofs_y = -7}, + {.bitmap_index = 23653, .adv_w = 327, .box_w = 22, .box_h = 34, .ofs_x = -1, .ofs_y = -7}, + {.bitmap_index = 24027, .adv_w = 170, .box_w = 5, .box_h = 4, .ofs_x = 3, .ofs_y = 11}, + {.bitmap_index = 24037, .adv_w = 338, .box_w = 17, .box_h = 17, .ofs_x = 2, .ofs_y = 1}, + {.bitmap_index = 24182, .adv_w = 507, .box_w = 31, .box_h = 29, .ofs_x = 1, .ofs_y = -2}, + {.bitmap_index = 24632, .adv_w = 202, .box_w = 7, .box_h = 6, .ofs_x = 4, .ofs_y = 23}, + {.bitmap_index = 24653, .adv_w = 406, .box_w = 27, .box_h = 27, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 25018, .adv_w = 477, .box_w = 30, .box_h = 27, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 25423, .adv_w = 509, .box_w = 31, .box_h = 27, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 25842, .adv_w = 233, .box_w = 13, .box_h = 27, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 26018, .adv_w = 471, .box_w = 30, .box_h = 27, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 26423, .adv_w = 520, .box_w = 34, .box_h = 27, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 26882, .adv_w = 457, .box_w = 29, .box_h = 27, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 27274, .adv_w = 135, .box_w = 14, .box_h = 28, .ofs_x = -3, .ofs_y = 0}, + {.bitmap_index = 27470, .adv_w = 406, .box_w = 27, .box_h = 27, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 27835, .adv_w = 406, .box_w = 22, .box_h = 27, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 28132, .adv_w = 335, .box_w = 18, .box_h = 27, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 28375, .adv_w = 406, .box_w = 27, .box_h = 27, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 28740, .adv_w = 406, .box_w = 21, .box_h = 27, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 29024, .adv_w = 372, .box_w = 23, .box_h = 27, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 29335, .adv_w = 439, .box_w = 22, .box_h = 27, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 29632, .adv_w = 473, .box_w = 27, .box_h = 27, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 29997, .adv_w = 170, .box_w = 5, .box_h = 27, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 30065, .adv_w = 406, .box_w = 24, .box_h = 27, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 30389, .adv_w = 406, .box_w = 26, .box_h = 27, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 30740, .adv_w = 506, .box_w = 27, .box_h = 27, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 31105, .adv_w = 439, .box_w = 22, .box_h = 27, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 31402, .adv_w = 395, .box_w = 21, .box_h = 27, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 31686, .adv_w = 473, .box_w = 27, .box_h = 27, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 32051, .adv_w = 439, .box_w = 22, .box_h = 27, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 32348, .adv_w = 406, .box_w = 22, .box_h = 27, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 32645, .adv_w = 376, .box_w = 20, .box_h = 27, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 32915, .adv_w = 372, .box_w = 23, .box_h = 27, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 33226, .adv_w = 406, .box_w = 26, .box_h = 27, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 33577, .adv_w = 485, .box_w = 28, .box_h = 29, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 33983, .adv_w = 406, .box_w = 26, .box_h = 27, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 34334, .adv_w = 508, .box_w = 28, .box_h = 27, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 34712, .adv_w = 455, .box_w = 26, .box_h = 27, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 35063, .adv_w = 170, .box_w = 12, .box_h = 33, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 35261, .adv_w = 406, .box_w = 26, .box_h = 33, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 35690, .adv_w = 352, .box_w = 20, .box_h = 29, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 35980, .adv_w = 271, .box_w = 16, .box_h = 29, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 36212, .adv_w = 338, .box_w = 17, .box_h = 36, .ofs_x = 2, .ofs_y = -7}, + {.bitmap_index = 36518, .adv_w = 135, .box_w = 8, .box_h = 28, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 36630, .adv_w = 333, .box_w = 17, .box_h = 28, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 36868, .adv_w = 352, .box_w = 20, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 37068, .adv_w = 350, .box_w = 19, .box_h = 34, .ofs_x = 2, .ofs_y = -7}, + {.bitmap_index = 37391, .adv_w = 304, .box_w = 19, .box_h = 27, .ofs_x = 0, .ofs_y = -7}, + {.bitmap_index = 37648, .adv_w = 338, .box_w = 19, .box_h = 27, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 37905, .adv_w = 271, .box_w = 16, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 38065, .adv_w = 268, .box_w = 16, .box_h = 34, .ofs_x = 1, .ofs_y = -7}, + {.bitmap_index = 38337, .adv_w = 338, .box_w = 17, .box_h = 27, .ofs_x = 2, .ofs_y = -7}, + {.bitmap_index = 38567, .adv_w = 338, .box_w = 19, .box_h = 27, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 38824, .adv_w = 135, .box_w = 4, .box_h = 20, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 38864, .adv_w = 303, .box_w = 17, .box_h = 20, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 39034, .adv_w = 304, .box_w = 19, .box_h = 27, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 39291, .adv_w = 338, .box_w = 17, .box_h = 27, .ofs_x = 2, .ofs_y = -7}, + {.bitmap_index = 39521, .adv_w = 304, .box_w = 19, .box_h = 20, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 39711, .adv_w = 272, .box_w = 16, .box_h = 34, .ofs_x = 1, .ofs_y = -7}, + {.bitmap_index = 39983, .adv_w = 338, .box_w = 19, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 40173, .adv_w = 419, .box_w = 26, .box_h = 20, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 40433, .adv_w = 346, .box_w = 19, .box_h = 27, .ofs_x = 2, .ofs_y = -7}, + {.bitmap_index = 40690, .adv_w = 293, .box_w = 17, .box_h = 27, .ofs_x = 1, .ofs_y = -7}, + {.bitmap_index = 40920, .adv_w = 375, .box_w = 22, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 41140, .adv_w = 240, .box_w = 15, .box_h = 20, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 41290, .adv_w = 333, .box_w = 17, .box_h = 20, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 41460, .adv_w = 394, .box_w = 23, .box_h = 27, .ofs_x = 1, .ofs_y = -7}, + {.bitmap_index = 41771, .adv_w = 319, .box_w = 20, .box_h = 27, .ofs_x = 0, .ofs_y = -7}, + {.bitmap_index = 42041, .adv_w = 433, .box_w = 23, .box_h = 27, .ofs_x = 2, .ofs_y = -7}, + {.bitmap_index = 42352, .adv_w = 475, .box_w = 28, .box_h = 20, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 42632, .adv_w = 135, .box_w = 12, .box_h = 27, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 42794, .adv_w = 333, .box_w = 17, .box_h = 27, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 43024, .adv_w = 338, .box_w = 19, .box_h = 29, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 43300, .adv_w = 333, .box_w = 17, .box_h = 29, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 43547, .adv_w = 475, .box_w = 28, .box_h = 29, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 43953, .adv_w = 202, .box_w = 15, .box_h = 5, .ofs_x = -1, .ofs_y = 23} +}; + +/*--------------------- + * CHARACTER MAPPING + *--------------------*/ + +static const uint8_t glyph_id_ofs_list_1[] = { + 0, 0, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 0, + 13, 14, 15, 16, 0, 17, 18, 19, + 0, 0, 0, 20, 0, 21 +}; + +static const uint8_t glyph_id_ofs_list_2[] = { + 0, 0, 1, 0, 2, 3, 4, 0, + 5 +}; + +/*Collect the unicode lists and glyph_id offsets*/ +static const lv_font_fmt_txt_cmap_t cmaps[] = +{ + { + .range_start = 32, .range_length = 95, .glyph_id_start = 1, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 160, .range_length = 30, .glyph_id_start = 96, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_1, .list_length = 30, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 900, .range_length = 9, .glyph_id_start = 118, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_2, .list_length = 9, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 910, .range_length = 20, .glyph_id_start = 124, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 931, .range_length = 44, .glyph_id_start = 144, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 1012, .range_length = 1, .glyph_id_start = 188, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + } +}; + + + +/*-------------------- + * ALL CUSTOM DATA + *--------------------*/ + +#if LVGL_VERSION_MAJOR == 8 +/*Store all the custom data of the font*/ +static lv_font_fmt_txt_glyph_cache_t cache; +#endif + +#if LVGL_VERSION_MAJOR >= 8 +static const lv_font_fmt_txt_dsc_t font_dsc = { +#else +static lv_font_fmt_txt_dsc_t font_dsc = { +#endif + .glyph_bitmap = glyph_bitmap, + .glyph_dsc = glyph_dsc, + .cmaps = cmaps, + .kern_dsc = NULL, + .kern_scale = 0, + .cmap_num = 6, + .bpp = 4, + .kern_classes = 0, + .bitmap_format = 0, +#if LVGL_VERSION_MAJOR == 8 + .cache = &cache +#endif + +}; + +extern const lv_font_t lv_font_montserrat_38; + + +/*----------------- + * PUBLIC FONT + *----------------*/ + +/*Initialize a public general font descriptor*/ +#if LVGL_VERSION_MAJOR >= 8 +const lv_font_t lv_font_arial_38 = { +#else +lv_font_t lv_font_arial_38 = { +#endif + .get_glyph_dsc = lv_font_get_glyph_dsc_fmt_txt, /*Function pointer to get glyph's data*/ + .get_glyph_bitmap = lv_font_get_bitmap_fmt_txt, /*Function pointer to get glyph's bitmap*/ + .line_height = 40, /*The maximum line height required by the font*/ + .base_line = 7, /*Baseline measured from the bottom of the line*/ +#if !(LVGL_VERSION_MAJOR == 6 && LVGL_VERSION_MINOR == 0) + .subpx = LV_FONT_SUBPX_NONE, +#endif +#if LV_VERSION_CHECK(7, 4, 0) || LVGL_VERSION_MAJOR >= 8 + .underline_position = -4, + .underline_thickness = 3, +#endif + //.static_bitmap = 0, + .dsc = &font_dsc, /*The custom font data. Will be accessed by `get_glyph_bitmap/dsc` */ +#if LV_VERSION_CHECK(8, 2, 0) || LVGL_VERSION_MAJOR >= 9 + .fallback = &lv_font_montserrat_38, +#endif + .user_data = NULL, +}; + + + +#endif /*#if LV_FONT_ARIAL_38*/ diff --git a/src/fonts/lv_font_arial_40.c b/src/fonts/lv_font_arial_40.c new file mode 100644 index 0000000000..88a5d9ef37 --- /dev/null +++ b/src/fonts/lv_font_arial_40.c @@ -0,0 +1,6810 @@ +/******************************************************************************* + * Size: 40 px + * Bpp: 4 + * Opts: --bpp 4 --size 40 --no-compress --stride 1 --align 1 --font Arial Greek Regular.ttf --range 32-127,160-255,880-1023 --format lvgl -o lv_font_arial_40.c + ******************************************************************************/ + +#ifdef __has_include + #if __has_include("lvgl.h") + #ifndef LV_LVGL_H_INCLUDE_SIMPLE + #define LV_LVGL_H_INCLUDE_SIMPLE + #endif + #endif +#endif + +#ifdef LV_LVGL_H_INCLUDE_SIMPLE + #include "lvgl.h" +#else + #include "lvgl/lvgl.h" +#endif + + + +#ifndef LV_FONT_ARIAL_40 +#define LV_FONT_ARIAL_40 1 +#endif + +#if LV_FONT_ARIAL_40 + +/*----------------- + * BITMAPS + *----------------*/ + +/*Store the image of the glyphs*/ +static LV_ATTRIBUTE_LARGE_CONST const uint8_t glyph_bitmap[] = { + /* U+0020 " " */ + + /* U+0021 "!" */ + 0xaf, 0xff, 0xba, 0xff, 0xfb, 0xaf, 0xff, 0xba, + 0xff, 0xfb, 0xaf, 0xff, 0xba, 0xff, 0xfb, 0x9f, + 0xff, 0xb8, 0xff, 0xfa, 0x7f, 0xff, 0x96, 0xff, + 0xf8, 0x5f, 0xff, 0x74, 0xff, 0xf6, 0x2f, 0xff, + 0x51, 0xff, 0xf3, 0xf, 0xff, 0x20, 0xff, 0xf1, + 0xe, 0xff, 0x0, 0xdf, 0xf0, 0xc, 0xfe, 0x0, + 0xaf, 0xd0, 0x9, 0xfc, 0x0, 0x25, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x87, 0xff, + 0xf9, 0x7f, 0xff, 0x97, 0xff, 0xf9, + + /* U+0022 "\"" */ + 0x2f, 0xff, 0xd0, 0xa, 0xff, 0xf5, 0x2f, 0xff, + 0xd0, 0xa, 0xff, 0xf5, 0x2f, 0xff, 0xd0, 0xa, + 0xff, 0xf5, 0x2f, 0xff, 0xd0, 0xa, 0xff, 0xf5, + 0x2f, 0xff, 0xd0, 0xa, 0xff, 0xf5, 0xf, 0xff, + 0xb0, 0x8, 0xff, 0xf3, 0xc, 0xff, 0x80, 0x5, + 0xff, 0xf0, 0xa, 0xff, 0x60, 0x2, 0xff, 0xd0, + 0x7, 0xff, 0x30, 0x0, 0xff, 0xa0, 0x4, 0xff, + 0x10, 0x0, 0xcf, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0023 "#" */ + 0x0, 0x0, 0x0, 0x0, 0xff, 0xe0, 0x0, 0x0, + 0xe, 0xff, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xa0, 0x0, 0x0, 0x2f, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0x60, 0x0, 0x0, 0x6f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0x20, 0x0, + 0x0, 0xaf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xfe, 0x0, 0x0, 0x0, 0xef, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xfb, 0x0, 0x0, 0x2, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf7, 0x0, + 0x0, 0x6, 0xff, 0x80, 0x0, 0x8f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x7e, 0xee, 0xee, 0xff, 0xfe, + 0xee, 0xee, 0xef, 0xff, 0xee, 0xeb, 0x0, 0x0, + 0x4, 0xff, 0xa0, 0x0, 0x0, 0x3f, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0x60, 0x0, 0x0, + 0x6f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0x30, 0x0, 0x0, 0xaf, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0x0, 0x0, 0x0, 0xdf, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xfd, 0x0, 0x0, + 0x0, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xf9, 0x0, 0x0, 0x4, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xf6, 0x0, 0x0, 0x7, 0xff, + 0x70, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x8f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x7e, 0xee, 0xff, 0xfe, 0xee, 0xee, 0xef, + 0xff, 0xee, 0xee, 0xeb, 0x0, 0x5, 0xff, 0x90, + 0x0, 0x0, 0x4f, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0x60, 0x0, 0x0, 0x7f, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0x20, 0x0, 0x0, + 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0x0, 0x0, 0x0, 0xef, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xfb, 0x0, 0x0, 0x1, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf8, 0x0, 0x0, + 0x4, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xf5, 0x0, 0x0, 0x8, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xf1, 0x0, 0x0, 0xb, 0xff, + 0x30, 0x0, 0x0, 0x0, + + /* U+0024 "$" */ + 0x0, 0x0, 0x0, 0x0, 0x7, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x59, + 0xbf, 0xfc, 0x95, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7e, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x7f, 0xff, 0xf8, 0x2f, 0xf5, + 0x9f, 0xff, 0xf6, 0x0, 0x1, 0xff, 0xfe, 0x20, + 0xf, 0xf1, 0x5, 0xff, 0xfe, 0x0, 0x7, 0xff, + 0xf3, 0x0, 0xf, 0xf1, 0x0, 0x9f, 0xff, 0x50, + 0xb, 0xff, 0xd0, 0x0, 0xf, 0xf1, 0x0, 0x3f, + 0xff, 0x90, 0xd, 0xff, 0xa0, 0x0, 0xf, 0xf1, + 0x0, 0x9, 0x75, 0x20, 0xd, 0xff, 0xb0, 0x0, + 0xf, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xe0, 0x0, 0xf, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xf7, 0x0, 0xf, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0x80, 0xf, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xfe, + 0x7f, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xfc, 0x72, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5d, 0xff, 0xff, 0xff, 0xff, 0xc4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4a, 0xef, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xfb, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xf1, 0x18, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xf1, 0x0, 0x4f, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xf1, + 0x0, 0xa, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xf1, 0x0, 0x5, 0xff, 0xf5, 0x39, 0xcf, + 0x20, 0x0, 0xf, 0xf1, 0x0, 0x3, 0xff, 0xf6, + 0x6f, 0xff, 0x50, 0x0, 0xf, 0xf1, 0x0, 0x3, + 0xff, 0xf5, 0x3f, 0xff, 0xa0, 0x0, 0xf, 0xf1, + 0x0, 0x6, 0xff, 0xf3, 0xe, 0xff, 0xf2, 0x0, + 0xf, 0xf1, 0x0, 0xd, 0xff, 0xe0, 0x8, 0xff, + 0xfc, 0x0, 0xf, 0xf1, 0x0, 0x9f, 0xff, 0x80, + 0x0, 0xdf, 0xff, 0xc4, 0xf, 0xf1, 0x3c, 0xff, + 0xfd, 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe2, 0x0, 0x0, 0x1, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x20, 0x0, 0x0, 0x0, + 0x3, 0x9d, 0xff, 0xff, 0xea, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0x80, 0x0, 0x0, 0x0, 0x0, + + /* U+0025 "%" */ + 0x0, 0x3, 0xae, 0xfe, 0xa2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xf9, 0x69, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x60, 0x0, 0x5f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xfe, 0x0, 0x0, 0xd, 0xff, 0x30, 0x0, + 0x0, 0x2, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfa, 0x0, 0x0, 0x9, 0xff, 0x70, 0x0, + 0x0, 0xa, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf8, 0x0, 0x0, 0x7, 0xff, 0x90, 0x0, + 0x0, 0x3f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xf7, 0x0, 0x0, 0x6, 0xff, 0xa0, 0x0, + 0x0, 0xbf, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf8, 0x0, 0x0, 0x7, 0xff, 0x90, 0x0, + 0x3, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xf9, 0x0, 0x0, 0x9, 0xff, 0x70, 0x0, + 0xc, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xfd, 0x0, 0x0, 0xd, 0xff, 0x40, 0x0, + 0x4f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x50, 0x0, 0x5f, 0xfd, 0x0, 0x0, + 0xcf, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xf9, 0x69, 0xff, 0xf4, 0x0, 0x5, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xff, 0x60, 0x0, 0xd, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xae, 0xfe, 0x92, 0x0, 0x0, 0x6f, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xe0, 0x0, 0x0, 0x7d, 0xff, 0xc7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0x70, 0x0, 0x1d, 0xff, 0xff, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xfe, + 0x0, 0x0, 0xcf, 0xfd, 0x77, 0xcf, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf6, + 0x0, 0x5, 0xff, 0xd0, 0x0, 0xc, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xe0, + 0x0, 0xb, 0xff, 0x60, 0x0, 0x4, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x60, + 0x0, 0xe, 0xff, 0x20, 0x0, 0x0, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xfd, 0x0, + 0x0, 0xf, 0xff, 0x0, 0x0, 0x0, 0xef, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf5, 0x0, + 0x0, 0xf, 0xff, 0x0, 0x0, 0x0, 0xef, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xd0, 0x0, + 0x0, 0xf, 0xff, 0x0, 0x0, 0x0, 0xef, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0x40, 0x0, + 0x0, 0xe, 0xff, 0x20, 0x0, 0x0, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xfc, 0x0, 0x0, + 0x0, 0xa, 0xff, 0x50, 0x0, 0x5, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf4, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xd0, 0x0, 0xc, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xfd, 0x77, 0xdf, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x1c, 0xff, 0xff, 0xff, 0xc1, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7c, 0xff, 0xc6, 0x0, 0x0, + + /* U+0026 "&" */ + 0x0, 0x0, 0x0, 0x1, 0x7c, 0xef, 0xeb, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xef, 0xff, 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xfe, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0x60, 0x2, 0xcf, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x50, 0x0, + 0x1, 0xef, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf0, 0x0, 0x0, 0xa, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xf5, 0x0, 0x0, 0xd, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xe1, 0x0, 0x6, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xc0, 0x6, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xab, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xff, + 0xe5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7e, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xdf, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xa6, 0xff, 0xff, 0x70, 0x0, + 0x1, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x50, + 0x7, 0xff, 0xff, 0x40, 0x0, 0xff, 0xb6, 0x0, + 0x3, 0xff, 0xfe, 0x30, 0x0, 0x9, 0xff, 0xff, + 0x20, 0x5f, 0xff, 0x80, 0x0, 0xbf, 0xff, 0x40, + 0x0, 0x0, 0xb, 0xff, 0xfe, 0x1b, 0xff, 0xf3, + 0x0, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x1d, + 0xff, 0xfd, 0xff, 0xfc, 0x0, 0x3, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x3f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xc0, 0x0, 0x1, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xf8, 0x0, 0x0, 0xd, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x5f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x4e, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0xbf, 0xff, 0xf9, + 0x41, 0x25, 0xbf, 0xff, 0xfa, 0xbf, 0xff, 0xf9, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0xbf, 0xff, 0xf8, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xd4, 0x0, 0x0, 0xbf, + 0xfc, 0x0, 0x0, 0x0, 0x28, 0xce, 0xfe, 0xda, + 0x40, 0x0, 0x0, 0x0, 0x8d, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+0027 "'" */ + 0x3f, 0xff, 0xd3, 0xff, 0xfd, 0x3f, 0xff, 0xd3, + 0xff, 0xfd, 0x2f, 0xff, 0xd0, 0xff, 0xfb, 0xe, + 0xff, 0x80, 0xbf, 0xf5, 0x8, 0xff, 0x20, 0x6f, + 0xf0, 0x0, 0x0, 0x0, + + /* U+0028 "(" */ + 0x0, 0x0, 0x0, 0x1e, 0xf9, 0x0, 0x0, 0x0, + 0xbf, 0xe0, 0x0, 0x0, 0x7, 0xff, 0x50, 0x0, + 0x0, 0x1f, 0xfd, 0x0, 0x0, 0x0, 0xbf, 0xf5, + 0x0, 0x0, 0x3, 0xff, 0xd0, 0x0, 0x0, 0xc, + 0xff, 0x60, 0x0, 0x0, 0x3f, 0xff, 0x10, 0x0, + 0x0, 0xaf, 0xfa, 0x0, 0x0, 0x0, 0xff, 0xf5, + 0x0, 0x0, 0x6, 0xff, 0xf1, 0x0, 0x0, 0xa, + 0xff, 0xc0, 0x0, 0x0, 0xe, 0xff, 0x90, 0x0, + 0x0, 0x2f, 0xff, 0x60, 0x0, 0x0, 0x4f, 0xff, + 0x40, 0x0, 0x0, 0x7f, 0xff, 0x20, 0x0, 0x0, + 0x8f, 0xff, 0x10, 0x0, 0x0, 0x8f, 0xff, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0x10, 0x0, 0x0, 0x7f, 0xff, 0x20, 0x0, + 0x0, 0x4f, 0xff, 0x40, 0x0, 0x0, 0x2f, 0xff, + 0x60, 0x0, 0x0, 0xe, 0xff, 0x90, 0x0, 0x0, + 0xb, 0xff, 0xc0, 0x0, 0x0, 0x6, 0xff, 0xf1, + 0x0, 0x0, 0x1, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0xaf, 0xfa, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x10, + 0x0, 0x0, 0xc, 0xff, 0x60, 0x0, 0x0, 0x4, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0xbf, 0xf5, 0x0, + 0x0, 0x0, 0x2f, 0xfd, 0x0, 0x0, 0x0, 0x7, + 0xff, 0x50, 0x0, 0x0, 0x0, 0xbf, 0xe0, 0x0, + 0x0, 0x0, 0x1e, 0xf9, + + /* U+0029 ")" */ + 0x3f, 0xf5, 0x0, 0x0, 0x0, 0xa, 0xff, 0x20, + 0x0, 0x0, 0x1, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x8f, 0xf6, 0x0, 0x0, 0x0, 0x1f, 0xfe, 0x10, + 0x0, 0x0, 0x8, 0xff, 0x80, 0x0, 0x0, 0x2, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0xbf, 0xf8, 0x0, + 0x0, 0x0, 0x5f, 0xfe, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x50, 0x0, 0x0, 0xc, 0xff, 0xb0, 0x0, + 0x0, 0x7, 0xff, 0xf0, 0x0, 0x0, 0x4, 0xff, + 0xf3, 0x0, 0x0, 0x1, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0xff, 0xf9, 0x0, 0x0, 0x0, 0xdf, 0xfc, + 0x0, 0x0, 0x0, 0xcf, 0xfd, 0x0, 0x0, 0x0, + 0xbf, 0xfe, 0x0, 0x0, 0x0, 0xbf, 0xfe, 0x0, + 0x0, 0x0, 0xcf, 0xfd, 0x0, 0x0, 0x0, 0xdf, + 0xfc, 0x0, 0x0, 0x0, 0xff, 0xfa, 0x0, 0x0, + 0x1, 0xff, 0xf7, 0x0, 0x0, 0x4, 0xff, 0xf4, + 0x0, 0x0, 0x8, 0xff, 0xf0, 0x0, 0x0, 0xc, + 0xff, 0xb0, 0x0, 0x0, 0xf, 0xff, 0x50, 0x0, + 0x0, 0x5f, 0xfe, 0x0, 0x0, 0x0, 0xbf, 0xf8, + 0x0, 0x0, 0x2, 0xff, 0xf1, 0x0, 0x0, 0x9, + 0xff, 0x80, 0x0, 0x0, 0x1f, 0xfe, 0x10, 0x0, + 0x0, 0x8f, 0xf6, 0x0, 0x0, 0x1, 0xff, 0xc0, + 0x0, 0x0, 0xa, 0xff, 0x20, 0x0, 0x0, 0x3f, + 0xf5, 0x0, 0x0, 0x0, + + /* U+002A "*" */ + 0x0, 0x0, 0xa, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0x0, 0x0, 0x0, 0xd, 0x93, 0x6, + 0xfe, 0x0, 0x6b, 0x80, 0x4f, 0xff, 0xc9, 0xfd, + 0x8f, 0xff, 0xd0, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe1, 0x0, 0x37, 0xaf, 0xff, 0xd9, 0x62, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xe3, 0x0, 0x0, + 0x0, 0x7, 0xff, 0x6e, 0xfe, 0x20, 0x0, 0x0, + 0x5f, 0xfd, 0x5, 0xff, 0xd1, 0x0, 0x0, 0xcf, + 0xf3, 0x0, 0xbf, 0xf6, 0x0, 0x0, 0x9, 0x90, + 0x0, 0x1d, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+002B "+" */ + 0x0, 0x0, 0x0, 0x0, 0xbb, 0xb4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf2, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf2, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x23, 0x33, + 0x33, 0x33, 0xff, 0xf7, 0x33, 0x33, 0x33, 0x30, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + + /* U+002C "," */ + 0x7f, 0xff, 0x78, 0xff, 0xf7, 0x8f, 0xff, 0x78, + 0xff, 0xf7, 0x0, 0x9f, 0x60, 0xb, 0xf5, 0x1, + 0xff, 0x11, 0xcf, 0x90, 0x7f, 0xc0, 0x0, 0x60, + 0x0, + + /* U+002D "-" */ + 0x58, 0x88, 0x88, 0x88, 0x88, 0x80, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xf1, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xf1, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xf1, + + /* U+002E "." */ + 0x6f, 0xff, 0x87, 0xff, 0xf9, 0x7f, 0xff, 0x97, + 0xff, 0xf9, + + /* U+002F "/" */ + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0x50, 0x0, 0x0, 0x0, 0xb, 0xff, 0x10, + 0x0, 0x0, 0x0, 0xf, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0xef, 0xe0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x8, 0xff, 0x40, 0x0, 0x0, 0x0, 0xd, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x9, 0xff, 0x30, 0x0, 0x0, 0x0, 0xe, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xf1, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x5, 0xff, 0x70, 0x0, + 0x0, 0x0, 0xa, 0xff, 0x20, 0x0, 0x0, 0x0, + 0xf, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x0, + + /* U+0030 "0" */ + 0x0, 0x0, 0x0, 0x4a, 0xdf, 0xfd, 0xb5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2c, 0xff, 0xff, 0xff, + 0xff, 0xd3, 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, + 0xff, 0xef, 0xff, 0xff, 0x30, 0x0, 0x0, 0xd, + 0xff, 0xfa, 0x20, 0x1, 0x8f, 0xff, 0xe1, 0x0, + 0x0, 0x7f, 0xff, 0x80, 0x0, 0x0, 0x5, 0xff, + 0xf9, 0x0, 0x0, 0xef, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0x10, 0x4, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x60, 0x9, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xb0, + 0xc, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xe0, 0xe, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf1, 0x1f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf3, 0x2f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf4, + 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf5, 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf6, 0x3f, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, 0x3f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf5, + 0x2f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf4, 0x1f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf3, 0xe, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf1, 0xc, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xe0, + 0x9, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xb0, 0x4, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0x60, 0x0, 0xef, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0x10, 0x0, 0x7f, + 0xff, 0x80, 0x0, 0x0, 0x5, 0xff, 0xf9, 0x0, + 0x0, 0xd, 0xff, 0xfa, 0x20, 0x1, 0x8f, 0xff, + 0xe1, 0x0, 0x0, 0x2, 0xef, 0xff, 0xfe, 0xef, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x2c, 0xff, + 0xff, 0xff, 0xff, 0xd3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4a, 0xdf, 0xfd, 0xb5, 0x0, 0x0, 0x0, + + /* U+0031 "1" */ + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0x0, 0x0, 0x0, 0x2e, 0xff, + 0xf0, 0x0, 0x0, 0x2e, 0xff, 0xff, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xf0, 0x1, 0xaf, 0xff, 0xff, + 0xff, 0x18, 0xff, 0xff, 0xeb, 0xff, 0xf9, 0xff, + 0xff, 0xb1, 0x8f, 0xff, 0x9f, 0xfe, 0x60, 0x8, + 0xff, 0xf9, 0xd7, 0x0, 0x0, 0x8f, 0xff, 0x10, + 0x0, 0x0, 0x8, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x8f, 0xff, + + /* U+0032 "2" */ + 0x0, 0x0, 0x0, 0x6a, 0xef, 0xfe, 0xc8, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x10, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xfe, 0xef, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x8f, + 0xff, 0xe6, 0x10, 0x0, 0x5d, 0xff, 0xfc, 0x0, + 0x2, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x60, 0x8, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xc0, 0xd, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf0, 0xf, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf1, + 0x2, 0x35, 0x30, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xd2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2d, 0xff, 0xfd, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xef, 0xff, + 0xb1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xfe, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xf9, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x50, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf2, 0x9f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + + /* U+0033 "3" */ + 0x0, 0x0, 0x1, 0x7b, 0xef, 0xfd, 0xa4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0xd3, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xfe, 0xef, 0xff, 0xff, 0x40, 0x0, 0x0, 0x8f, + 0xff, 0xd4, 0x0, 0x2, 0x8f, 0xff, 0xf2, 0x0, + 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xfa, 0x0, 0x8, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x0, 0xb, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0x10, 0x0, 0x13, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x37, 0xef, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xe5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xd7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xdb, 0xbd, + 0xff, 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2b, 0xff, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf7, 0x1, 0x35, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf7, + 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf6, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf2, 0x9, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xd0, 0x2, 0xff, + 0xfe, 0x20, 0x0, 0x0, 0x2, 0xef, 0xff, 0x40, + 0x0, 0x8f, 0xff, 0xe6, 0x0, 0x1, 0x7f, 0xff, + 0xf9, 0x0, 0x0, 0xa, 0xff, 0xff, 0xfe, 0xef, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xe5, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x7b, 0xef, 0xfd, 0xa5, 0x0, 0x0, 0x0, + + /* U+0034 "4" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xfe, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0x4f, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x80, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xd0, 0xf, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf2, 0x0, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xf6, 0x0, 0xf, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfb, + 0x0, 0x0, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xfe, 0x10, 0x0, 0xf, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x40, 0x0, 0x0, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0xd, 0xff, 0x80, 0x0, + 0x0, 0xf, 0xff, 0x80, 0x0, 0x0, 0x9, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0xff, 0xf8, 0x0, 0x0, + 0x5, 0xff, 0xf2, 0x0, 0x0, 0x0, 0xf, 0xff, + 0x80, 0x0, 0x1, 0xef, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf8, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x66, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x61, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0xff, 0xf9, 0x33, 0x31, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf8, 0x0, 0x0, + + /* U+0035 "5" */ + 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x8, + 0xff, 0xe5, 0x55, 0x55, 0x55, 0x55, 0x55, 0x10, + 0x0, 0xb, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xfa, 0x6, 0xbf, 0xff, + 0xea, 0x40, 0x0, 0x0, 0x0, 0xef, 0xfb, 0xef, + 0xff, 0xff, 0xff, 0xfb, 0x10, 0x0, 0x1, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe2, 0x0, + 0x4, 0xff, 0xff, 0xd7, 0x20, 0x3, 0x8f, 0xff, + 0xfe, 0x10, 0x7, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x2, 0xdf, 0xff, 0x90, 0x3, 0x68, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf9, + 0x2e, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf6, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf2, 0xb, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xb0, 0x5, 0xff, + 0xfe, 0x20, 0x0, 0x0, 0x2, 0xef, 0xff, 0x30, + 0x0, 0xbf, 0xff, 0xe6, 0x10, 0x1, 0x6e, 0xff, + 0xf7, 0x0, 0x0, 0xc, 0xff, 0xff, 0xfe, 0xef, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xff, 0xe6, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x7b, 0xef, 0xfd, 0xb6, 0x10, 0x0, 0x0, + + /* U+0036 "6" */ + 0x0, 0x0, 0x0, 0x16, 0xbd, 0xff, 0xda, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xef, 0xff, 0xff, + 0xff, 0xfd, 0x40, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xef, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x8, + 0xff, 0xfd, 0x50, 0x0, 0x2a, 0xff, 0xfe, 0x10, + 0x0, 0x3f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0x80, 0x0, 0xbf, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xd0, 0x2, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x5, 0x98, 0x70, 0x7, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0x70, 0x3, 0x9d, 0xef, + 0xda, 0x40, 0x0, 0x0, 0x1f, 0xff, 0x40, 0x9f, + 0xff, 0xff, 0xff, 0xfb, 0x10, 0x0, 0x3f, 0xff, + 0x3c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd1, 0x0, + 0x4f, 0xff, 0xcf, 0xfd, 0x62, 0x12, 0x7e, 0xff, + 0xfc, 0x0, 0x5f, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x1, 0xdf, 0xff, 0x70, 0x5f, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xe0, 0x5f, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf3, + 0x4f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf6, 0x3f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xf8, 0x1f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf8, 0xf, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf7, + 0xb, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf5, 0x7, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf1, 0x1, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xb0, 0x0, 0x9f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x40, + 0x0, 0xd, 0xff, 0xfc, 0x40, 0x0, 0x4d, 0xff, + 0xf9, 0x0, 0x0, 0x1, 0xcf, 0xff, 0xff, 0xef, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x27, 0xce, 0xfe, 0xd8, 0x20, 0x0, 0x0, + + /* U+0037 "7" */ + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf8, 0xf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x5, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x8f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, + 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0038 "8" */ + 0x0, 0x0, 0x0, 0x5a, 0xdf, 0xfe, 0xb7, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x4e, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xfe, 0xef, 0xff, 0xff, 0x80, 0x0, 0x0, 0x2f, + 0xff, 0xf8, 0x10, 0x0, 0x7f, 0xff, 0xf5, 0x0, + 0x0, 0xaf, 0xff, 0x50, 0x0, 0x0, 0x3, 0xff, + 0xfe, 0x0, 0x0, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0x30, 0x1, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x50, 0x1, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x50, + 0x0, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0x20, 0x0, 0xaf, 0xff, 0x70, 0x0, 0x0, + 0x3, 0xff, 0xfc, 0x0, 0x0, 0x1e, 0xff, 0xfa, + 0x30, 0x2, 0x8f, 0xff, 0xe2, 0x0, 0x0, 0x2, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x20, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xb2, + 0x0, 0x0, 0x0, 0x3, 0xcf, 0xff, 0xfe, 0xef, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x5f, 0xff, 0xe6, + 0x0, 0x0, 0x5d, 0xff, 0xfb, 0x0, 0x2, 0xff, + 0xfd, 0x10, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, + 0xa, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xe0, 0xf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xf4, 0x3f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf7, 0x4f, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf8, + 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf7, 0x1f, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf5, 0xc, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf0, 0x5, 0xff, + 0xfd, 0x20, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x90, + 0x0, 0xbf, 0xff, 0xe7, 0x10, 0x0, 0x4c, 0xff, + 0xfd, 0x10, 0x0, 0xb, 0xff, 0xff, 0xfe, 0xef, + 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6a, 0xef, 0xfe, 0xb7, 0x10, 0x0, 0x0, + + /* U+0039 "9" */ + 0x0, 0x0, 0x1, 0x7b, 0xef, 0xed, 0x93, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0xb2, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xef, 0xff, 0xfe, 0x30, 0x0, 0x0, 0x8f, + 0xff, 0xf8, 0x20, 0x1, 0x6e, 0xff, 0xf2, 0x0, + 0x2, 0xff, 0xff, 0x40, 0x0, 0x0, 0x2, 0xef, + 0xfc, 0x0, 0x9, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x40, 0xe, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xa0, 0x2f, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, + 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf2, 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xf5, 0x2f, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xf6, 0xf, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf8, + 0xb, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf8, 0x4, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x3, 0xef, 0xff, 0xf8, 0x0, 0xaf, 0xff, 0xfa, + 0x41, 0x13, 0x8f, 0xfd, 0xff, 0xf8, 0x0, 0xc, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xe2, 0xff, 0xf7, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xfb, 0x10, + 0xff, 0xf6, 0x0, 0x0, 0x2, 0x8d, 0xff, 0xea, + 0x40, 0x1, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, + 0x0, 0x12, 0x20, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xb0, 0xa, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x60, 0x6, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x0, 0x1, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf7, 0x0, + 0x0, 0x9f, 0xff, 0xb2, 0x0, 0x4, 0xcf, 0xff, + 0xc0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xee, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x3, 0x9d, 0xff, 0xec, 0x72, 0x0, 0x0, 0x0, + + /* U+003A ":" */ + 0x7f, 0xff, 0x97, 0xff, 0xf9, 0x7f, 0xff, 0x96, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xf8, 0x7f, 0xff, 0x97, + 0xff, 0xf9, 0x7f, 0xff, 0x90, + + /* U+003B ";" */ + 0x8f, 0xff, 0x78, 0xff, 0xf7, 0x8f, 0xff, 0x77, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf7, 0x8f, 0xff, 0x78, + 0xff, 0xf7, 0x8f, 0xff, 0x70, 0x9, 0xf6, 0x0, + 0xbf, 0x50, 0x1f, 0xf1, 0x1c, 0xf9, 0x7, 0xfc, + 0x0, 0x6, 0x0, 0x0, + + /* U+003C "<" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x41, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x7d, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0x9f, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xcf, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x18, 0xef, 0xff, 0xff, + 0xe9, 0x20, 0x0, 0x0, 0x0, 0x4a, 0xff, 0xff, + 0xff, 0xc6, 0x0, 0x0, 0x0, 0x0, 0x6d, 0xff, + 0xff, 0xff, 0x93, 0x0, 0x0, 0x0, 0x2, 0x9f, + 0xff, 0xff, 0xfd, 0x60, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xfa, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xd7, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xd7, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xf9, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x9f, 0xff, 0xff, 0xfc, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6d, 0xff, 0xff, 0xfe, + 0x92, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4b, + 0xff, 0xff, 0xff, 0xb5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x28, 0xef, 0xff, 0xff, 0xe8, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xcf, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xaf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x7e, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x51, + + /* U+003D "=" */ + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf2, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf2, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x34, 0x44, + 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x34, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, + 0x44, 0x40, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf2, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + + /* U+003E ">" */ + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0x92, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xc5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xe8, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xdf, 0xff, 0xff, 0xfa, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xaf, 0xff, 0xff, 0xfd, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x7d, + 0xff, 0xff, 0xff, 0x92, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4a, 0xff, 0xff, 0xff, 0xc5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x17, 0xef, 0xff, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xbf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xbf, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x17, 0xdf, 0xff, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x3a, 0xff, 0xff, 0xff, + 0xb5, 0x0, 0x0, 0x0, 0x0, 0x6d, 0xff, 0xff, + 0xff, 0x92, 0x0, 0x0, 0x0, 0x2, 0x9f, 0xff, + 0xff, 0xfd, 0x60, 0x0, 0x0, 0x0, 0x5, 0xcf, + 0xff, 0xff, 0xfb, 0x40, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xe8, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xc6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xa3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x51, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+003F "?" */ + 0x0, 0x0, 0x1, 0x6b, 0xef, 0xfe, 0xc8, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x10, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xfe, 0xef, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x8f, + 0xff, 0xf7, 0x10, 0x0, 0x5d, 0xff, 0xfe, 0x10, + 0x2, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x90, 0x8, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xf0, 0xd, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xf3, 0x1f, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf4, + 0x0, 0x24, 0x20, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xfc, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x12, 0x21, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0x10, 0x0, 0x0, 0x0, + + /* U+0040 "@" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x7a, + 0xce, 0xff, 0xfe, 0xca, 0x73, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x29, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe7, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1a, 0xff, 0xff, 0xff, 0xfe, 0xdd, + 0xef, 0xff, 0xff, 0xff, 0xe6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xfc, + 0x73, 0x0, 0x0, 0x0, 0x15, 0x9e, 0xff, 0xff, + 0xb1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xfa, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5d, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xfa, 0x0, 0x0, 0x0, 0x29, 0xdf, 0xec, 0x60, + 0x0, 0xbf, 0xfc, 0x0, 0x4f, 0xff, 0x50, 0x0, + 0x0, 0xb, 0xff, 0xc0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0xfc, 0x20, 0xdf, 0xf9, 0x0, 0x7, + 0xff, 0xd0, 0x0, 0x0, 0x4f, 0xfe, 0x10, 0x0, + 0x1, 0xcf, 0xff, 0xff, 0xef, 0xff, 0xe2, 0xff, + 0xf6, 0x0, 0x0, 0xdf, 0xf5, 0x0, 0x0, 0xcf, + 0xf5, 0x0, 0x0, 0xc, 0xff, 0xfa, 0x20, 0x1, + 0xaf, 0xfd, 0xff, 0xf2, 0x0, 0x0, 0x6f, 0xfb, + 0x0, 0x3, 0xff, 0xd0, 0x0, 0x0, 0x9f, 0xff, + 0x80, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x1f, 0xff, 0x0, 0x9, 0xff, 0x50, 0x0, + 0x4, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xb0, 0x0, 0x0, 0xc, 0xff, 0x20, 0xe, + 0xff, 0x0, 0x0, 0xd, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x80, 0x0, 0x0, 0xb, + 0xff, 0x30, 0x3f, 0xfb, 0x0, 0x0, 0x5f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x50, + 0x0, 0x0, 0x9, 0xff, 0x40, 0x6f, 0xf7, 0x0, + 0x0, 0xaf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x10, 0x0, 0x0, 0xa, 0xff, 0x30, + 0x8f, 0xf5, 0x0, 0x0, 0xef, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x0, + 0xc, 0xff, 0x10, 0xaf, 0xf3, 0x0, 0x2, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfb, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x0, 0xbf, 0xf2, + 0x0, 0x3, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xf7, 0x0, 0x0, 0x0, 0x5f, 0xfa, + 0x0, 0xbf, 0xf3, 0x0, 0x4, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0xcf, 0xf5, 0x0, 0xaf, 0xf4, 0x0, 0x3, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf1, 0x0, 0x0, 0x6, 0xff, 0xd0, 0x0, 0x9f, + 0xf6, 0x0, 0x1, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xd0, 0x0, 0x0, 0x2e, 0xff, + 0x50, 0x0, 0x7f, 0xf9, 0x0, 0x0, 0xdf, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xa0, 0x0, + 0x1, 0xdf, 0xfa, 0x0, 0x0, 0x3f, 0xfd, 0x0, + 0x0, 0x7f, 0xff, 0x80, 0x0, 0x0, 0x1c, 0xff, + 0xff, 0x80, 0x0, 0x4e, 0xff, 0xd0, 0x0, 0x0, + 0xf, 0xff, 0x20, 0x0, 0x1e, 0xff, 0xf8, 0x0, + 0x5, 0xdf, 0xff, 0xff, 0xe5, 0x5b, 0xff, 0xfe, + 0x20, 0x0, 0x0, 0xa, 0xff, 0x90, 0x0, 0x4, + 0xff, 0xff, 0xfe, 0xff, 0xfe, 0x3f, 0xff, 0xff, + 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf2, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xc1, + 0xb, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xfc, 0x0, 0x0, 0x1, 0x8d, + 0xfe, 0xb5, 0x0, 0x1, 0x9d, 0xff, 0xc7, 0x10, + 0x0, 0x3, 0x77, 0x60, 0x0, 0x2f, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, 0xa0, 0x0, + 0x5, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xef, + 0xfd, 0x10, 0x0, 0x0, 0x7f, 0xff, 0xd4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xc5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x7e, 0xff, 0xfc, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x4e, 0xff, 0xff, 0xfb, 0x74, + 0x10, 0x0, 0x0, 0x1, 0x37, 0xbf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0xee, 0xee, 0xff, 0xff, + 0xff, 0xff, 0xb3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x7c, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0xa3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x15, + 0x8b, 0xde, 0xff, 0xfe, 0xec, 0xa7, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0041 "A" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xfc, 0xdf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf8, 0x8f, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xf4, 0x2f, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xe0, 0xc, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0x90, 0x6, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x30, 0x1, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xfc, 0x0, 0x0, 0xaf, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf6, 0x0, 0x0, 0x3f, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, + 0x0, 0x0, 0xd, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xa0, 0x0, 0x0, + 0x7, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x30, 0x0, 0x0, 0x1, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x11, 0x11, + 0x11, 0x11, 0x11, 0x11, 0xbf, 0xff, 0x30, 0x0, + 0x0, 0x1, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xa0, 0x0, 0x0, 0x7, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xf1, 0x0, 0x0, 0xd, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf7, 0x0, 0x0, 0x4f, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfe, 0x0, + 0x0, 0xaf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x50, 0x1, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xb0, 0x6, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xf2, 0xd, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf9, + + /* U+0042 "B" */ + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xb8, + 0x30, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc3, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0xff, 0xfd, 0x55, 0x55, 0x55, + 0x66, 0x8b, 0xff, 0xff, 0xf2, 0x0, 0xf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xbf, 0xff, + 0xa0, 0x0, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0x0, 0xf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf1, + 0x0, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0x20, 0xf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf0, 0x0, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xfb, 0x0, 0xf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xbf, 0xff, 0x30, 0x0, 0xff, + 0xfd, 0x55, 0x55, 0x55, 0x56, 0x8b, 0xff, 0xff, + 0x50, 0x0, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x30, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd7, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x30, 0x0, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x24, 0x8e, 0xff, 0xfe, 0x20, + 0xf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xfb, 0x0, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf3, 0xf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0x70, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf8, 0xf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x80, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf6, 0xf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0x20, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xdf, 0xff, 0xb0, 0xf, 0xff, 0xd5, 0x55, + 0x55, 0x55, 0x56, 0x9d, 0xff, 0xff, 0xf2, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf4, 0x0, 0xf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc2, 0x0, 0x0, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xed, 0xa7, 0x20, + 0x0, 0x0, + + /* U+0043 "C" */ + 0x0, 0x0, 0x0, 0x0, 0x27, 0xbd, 0xef, 0xfd, + 0xa7, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x10, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x2, 0xdf, 0xff, 0xfe, 0xa6, 0x53, 0x46, 0xaf, + 0xff, 0xff, 0x50, 0x0, 0x0, 0xd, 0xff, 0xfe, + 0x70, 0x0, 0x0, 0x0, 0x2, 0xcf, 0xff, 0xf3, + 0x0, 0x0, 0xbf, 0xff, 0xe2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xfc, 0x0, 0x4, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0x50, 0xc, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xb0, + 0x2f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0x74, 0x0, 0x6f, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xd9, 0x50, 0x1f, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf2, 0xa, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xd0, 0x3, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x60, 0x0, 0x9f, + 0xff, 0xd2, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xfd, 0x0, 0x0, 0xe, 0xff, 0xfe, 0x60, + 0x0, 0x0, 0x0, 0x3, 0xdf, 0xff, 0xf3, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xfe, 0x95, 0x43, 0x47, + 0xcf, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x2d, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7e, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x59, 0xce, 0xff, 0xed, 0xa6, + 0x10, 0x0, 0x0, 0x0, + + /* U+0044 "D" */ + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xed, 0xb7, + 0x30, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x30, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0xdf, 0xff, 0x55, 0x55, + 0x55, 0x56, 0x7a, 0xdf, 0xff, 0xff, 0x50, 0x0, + 0xdf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xcf, 0xff, 0xf3, 0x0, 0xdf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xfd, 0x0, + 0xdf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0x50, 0xdf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xc0, + 0xdf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf1, 0xdf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf5, + 0xdf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xf8, 0xdf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfa, + 0xdf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xfc, 0xdf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfc, + 0xdf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xfc, 0xdf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfb, + 0xdf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xfa, 0xdf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf7, + 0xdf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf4, 0xdf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf0, + 0xdf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xb0, 0xdf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0x40, + 0xdf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xfc, 0x0, 0xdf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xdf, 0xff, 0xf2, 0x0, + 0xdf, 0xff, 0x55, 0x55, 0x55, 0x56, 0x7a, 0xef, + 0xff, 0xff, 0x50, 0x0, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0x20, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xec, 0x95, 0x10, 0x0, 0x0, 0x0, + + /* U+0045 "E" */ + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe0, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe0, 0xdf, 0xff, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x40, 0xdf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x54, 0x0, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x0, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x0, 0xdf, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x52, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf8, + + /* U+0046 "F" */ + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf8, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xcf, 0xff, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x52, + 0xcf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x52, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf7, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf7, 0x0, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0xcf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0047 "G" */ + 0x0, 0x0, 0x0, 0x0, 0x15, 0x9c, 0xde, 0xff, + 0xeb, 0x84, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb1, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xfc, 0x85, 0x43, + 0x46, 0x9e, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xa2, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xef, 0xff, 0xa0, 0x0, 0x5, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, + 0x30, 0x1, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xfa, 0x0, 0x8f, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xe0, 0xe, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x36, + 0x20, 0x4, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0xef, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x9c, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0xbf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x35, + 0x55, 0x55, 0x55, 0x7f, 0xff, 0x99, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf9, 0x4f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x90, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf9, 0x8, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0x90, 0x1f, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf9, 0x0, 0x6f, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xef, 0xff, 0x90, 0x0, + 0x8f, 0xff, 0xfd, 0x60, 0x0, 0x0, 0x0, 0x1, + 0x6d, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xfb, 0x87, 0x67, 0x8c, 0xff, 0xff, 0xff, + 0xe5, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xa1, 0x0, 0x0, + 0x0, 0x0, 0x17, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf9, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x48, 0xbd, 0xef, 0xfe, 0xc9, 0x50, 0x0, + 0x0, 0x0, + + /* U+0048 "H" */ + 0xcf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xac, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfa, 0xcf, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xac, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xfa, 0xcf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xac, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xfa, 0xcf, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xac, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xfa, 0xcf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xac, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xfa, 0xcf, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xac, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xac, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0xcf, 0xff, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x6f, 0xff, 0xac, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfa, + 0xcf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xac, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfa, 0xcf, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xac, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xfa, 0xcf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xac, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xfa, 0xcf, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xac, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xfa, 0xcf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xac, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xfa, 0xcf, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xac, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xfa, + + /* U+0049 "I" */ + 0x5f, 0xff, 0x75, 0xff, 0xf7, 0x5f, 0xff, 0x75, + 0xff, 0xf7, 0x5f, 0xff, 0x75, 0xff, 0xf7, 0x5f, + 0xff, 0x75, 0xff, 0xf7, 0x5f, 0xff, 0x75, 0xff, + 0xf7, 0x5f, 0xff, 0x75, 0xff, 0xf7, 0x5f, 0xff, + 0x75, 0xff, 0xf7, 0x5f, 0xff, 0x75, 0xff, 0xf7, + 0x5f, 0xff, 0x75, 0xff, 0xf7, 0x5f, 0xff, 0x75, + 0xff, 0xf7, 0x5f, 0xff, 0x75, 0xff, 0xf7, 0x5f, + 0xff, 0x75, 0xff, 0xf7, 0x5f, 0xff, 0x75, 0xff, + 0xf7, 0x5f, 0xff, 0x75, 0xff, 0xf7, + + /* U+004A "J" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfe, + 0x58, 0xa7, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfd, + 0xcf, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfc, + 0xbf, 0xfe, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfa, + 0x9f, 0xff, 0x30, 0x0, 0x0, 0x6, 0xff, 0xf7, + 0x4f, 0xff, 0xd1, 0x0, 0x0, 0x2e, 0xff, 0xf3, + 0xd, 0xff, 0xfe, 0x85, 0x69, 0xff, 0xff, 0xc0, + 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x20, + 0x0, 0x4e, 0xff, 0xff, 0xff, 0xff, 0xc2, 0x0, + 0x0, 0x0, 0x7b, 0xef, 0xfd, 0xa4, 0x0, 0x0, + + /* U+004B "K" */ + 0xf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf8, 0x0, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf8, + 0x0, 0xf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xf7, 0x0, 0x0, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf6, + 0x0, 0x0, 0xf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf5, 0x0, 0x0, 0x0, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xe3, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xb0, 0x0, + 0x0, 0xbf, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xfb, 0x0, 0x0, 0xbf, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xb0, + 0x0, 0xbf, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xfb, 0x0, 0xcf, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xb0, 0xcf, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xfc, 0xcf, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xff, 0xb2, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xa0, + 0x6, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0x90, 0x0, 0xa, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x90, + 0x0, 0x0, 0xe, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xe1, 0x0, 0x0, 0x0, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xb0, 0x0, 0x0, 0xf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0x70, 0x0, 0x0, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0x30, 0x0, 0xf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xfe, 0x10, + 0x0, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xfb, 0x0, 0xf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xf7, 0x0, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf4, + + /* U+004C "L" */ + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xfd, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x54, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, + + /* U+004D "M" */ + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xf5, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xf5, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xf5, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf5, + 0xff, 0xfe, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf5, 0xff, 0xfa, + 0xef, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xfa, 0xff, 0xf5, 0xff, 0xfa, 0x8f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf5, + 0xff, 0xf5, 0xff, 0xfa, 0x2f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xa5, 0xff, 0xf5, + 0xff, 0xfa, 0xd, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0x45, 0xff, 0xf5, 0xff, 0xfa, + 0x7, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xfe, 0x5, 0xff, 0xf5, 0xff, 0xfa, 0x2, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, 0x5, + 0xff, 0xf5, 0xff, 0xfa, 0x0, 0xcf, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf3, 0x5, 0xff, 0xf5, + 0xff, 0xfa, 0x0, 0x7f, 0xff, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xd0, 0x5, 0xff, 0xf5, 0xff, 0xfa, + 0x0, 0x1f, 0xff, 0x50, 0x0, 0x0, 0x8, 0xff, + 0x80, 0x5, 0xff, 0xf5, 0xff, 0xfa, 0x0, 0xc, + 0xff, 0xa0, 0x0, 0x0, 0xd, 0xff, 0x20, 0x5, + 0xff, 0xf5, 0xff, 0xfa, 0x0, 0x6, 0xff, 0xf0, + 0x0, 0x0, 0x3f, 0xfc, 0x0, 0x5, 0xff, 0xf5, + 0xff, 0xfa, 0x0, 0x1, 0xff, 0xf5, 0x0, 0x0, + 0x9f, 0xf7, 0x0, 0x5, 0xff, 0xf5, 0xff, 0xfa, + 0x0, 0x0, 0xbf, 0xfb, 0x0, 0x0, 0xef, 0xf1, + 0x0, 0x5, 0xff, 0xf5, 0xff, 0xfa, 0x0, 0x0, + 0x5f, 0xff, 0x0, 0x4, 0xff, 0xb0, 0x0, 0x5, + 0xff, 0xf5, 0xff, 0xfa, 0x0, 0x0, 0xf, 0xff, + 0x50, 0xa, 0xff, 0x60, 0x0, 0x5, 0xff, 0xf5, + 0xff, 0xfa, 0x0, 0x0, 0xa, 0xff, 0xb0, 0xf, + 0xff, 0x0, 0x0, 0x5, 0xff, 0xf5, 0xff, 0xfa, + 0x0, 0x0, 0x5, 0xff, 0xf1, 0x5f, 0xfa, 0x0, + 0x0, 0x5, 0xff, 0xf5, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0xff, 0xf5, 0xaf, 0xf4, 0x0, 0x0, 0x5, + 0xff, 0xf5, 0xff, 0xfa, 0x0, 0x0, 0x0, 0xaf, + 0xfb, 0xff, 0xe0, 0x0, 0x0, 0x5, 0xff, 0xf5, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x5, 0xff, 0xf5, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x5, 0xff, 0xf5, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf5, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf5, + + /* U+004E "N" */ + 0xdf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xbd, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfb, 0xdf, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xbd, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xfb, 0xdf, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xbd, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xfb, 0xdf, 0xfd, 0xdf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xbd, 0xff, 0xc3, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xfb, 0xdf, 0xfc, 0x7, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xbd, + 0xff, 0xc0, 0xc, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xfb, 0xdf, 0xfc, 0x0, 0x2f, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0xe, 0xff, 0xbd, 0xff, + 0xc0, 0x0, 0x7f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0xef, 0xfb, 0xdf, 0xfc, 0x0, 0x0, 0xcf, 0xff, + 0x90, 0x0, 0x0, 0xe, 0xff, 0xbd, 0xff, 0xc0, + 0x0, 0x2, 0xff, 0xff, 0x40, 0x0, 0x0, 0xef, + 0xfb, 0xdf, 0xfc, 0x0, 0x0, 0x6, 0xff, 0xfe, + 0x10, 0x0, 0xe, 0xff, 0xbd, 0xff, 0xc0, 0x0, + 0x0, 0xb, 0xff, 0xfa, 0x0, 0x0, 0xef, 0xfb, + 0xdf, 0xfc, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xf5, + 0x0, 0xe, 0xff, 0xbd, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xe1, 0x0, 0xef, 0xfb, 0xdf, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, + 0xe, 0xff, 0xbd, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0x60, 0xef, 0xfb, 0xdf, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x2e, + 0xff, 0xbd, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xfc, 0xef, 0xfb, 0xdf, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, + 0xbd, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xfb, 0xdf, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xbd, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xfb, 0xdf, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xbd, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xfb, + + /* U+004F "O" */ + 0x0, 0x0, 0x0, 0x0, 0x2, 0x6b, 0xde, 0xfe, + 0xdb, 0x73, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3b, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xcf, 0xff, + 0xff, 0xb7, 0x54, 0x56, 0xae, 0xff, 0xff, 0xd2, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf8, 0x10, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xe3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xef, 0xff, 0xb0, 0x0, 0x0, + 0x4f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xef, 0xff, 0x60, 0x0, 0xc, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xfd, 0x0, 0x3, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf5, 0x0, 0x7f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x90, 0xb, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfe, 0x0, + 0xef, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf0, 0xf, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x21, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf3, 0x1f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0x30, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf2, + 0xf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x10, 0xcf, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xe0, 0x7, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xfa, 0x0, 0x2f, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x50, 0x0, 0xcf, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xe0, + 0x0, 0x4, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xf6, 0x0, 0x0, + 0xa, 0xff, 0xfe, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2d, 0xff, 0xfb, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x7e, + 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x1d, 0xff, + 0xff, 0xea, 0x64, 0x34, 0x6a, 0xef, 0xff, 0xfd, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x27, 0xbd, 0xff, 0xed, + 0xb7, 0x20, 0x0, 0x0, 0x0, 0x0, + + /* U+0050 "P" */ + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xca, + 0x71, 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x0, 0xef, 0xfe, 0x55, 0x55, 0x55, 0x55, 0x56, + 0x9e, 0xff, 0xff, 0xa0, 0xef, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf3, 0xef, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xf9, 0xef, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xfc, 0xef, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfe, + 0xef, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xfe, 0xef, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xfc, 0xef, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf8, 0xef, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xf3, 0xef, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x2, 0x6c, 0xff, 0xff, 0xa0, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x10, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb1, 0x0, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0xa4, 0x0, 0x0, + 0xef, 0xfe, 0x55, 0x55, 0x55, 0x55, 0x43, 0x10, + 0x0, 0x0, 0x0, 0xef, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0051 "Q" */ + 0x0, 0x0, 0x0, 0x0, 0x2, 0x6b, 0xde, 0xff, + 0xeb, 0x83, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3c, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xb1, 0x0, 0x0, 0x0, 0x0, 0x1, 0xcf, 0xff, + 0xff, 0xb7, 0x54, 0x56, 0xae, 0xff, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf8, 0x10, + 0x0, 0x0, 0x0, 0x7, 0xef, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xe3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xdf, 0xff, 0xc0, 0x0, 0x0, + 0x3f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0x60, 0x0, 0xb, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xfe, 0x0, 0x3, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf5, 0x0, 0x7f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xa0, 0xb, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfe, 0x0, + 0xef, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf1, 0xf, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x31, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf3, 0x1f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0x30, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf3, + 0xe, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x10, 0xbf, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xe0, 0x7, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xfa, 0x0, 0x2f, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x50, 0x0, 0xbf, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x9, 0xe8, 0x10, 0x0, 0x4f, 0xff, 0xe0, + 0x0, 0x3, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0xef, 0xff, 0x80, 0x2e, 0xff, 0xf6, 0x0, 0x0, + 0x8, 0xff, 0xfe, 0x30, 0x0, 0x0, 0x2d, 0xff, + 0xff, 0xdd, 0xff, 0xfc, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x2, 0x9f, 0xff, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x1c, 0xff, + 0xff, 0xea, 0x64, 0x34, 0x6a, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb6, 0xef, 0xff, 0xe6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x27, 0xbd, 0xef, 0xfd, + 0xb7, 0x20, 0x1, 0xaf, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3c, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0x80, + + /* U+0052 "R" */ + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0xc9, 0x50, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x30, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0xcf, + 0xff, 0x22, 0x22, 0x22, 0x22, 0x22, 0x36, 0xaf, + 0xff, 0xfe, 0x10, 0x0, 0xcf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x70, + 0x0, 0xcf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xd0, 0x0, 0xcf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf0, 0x0, 0xcf, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf1, 0x0, + 0xcf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf0, 0x0, 0xcf, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xc0, 0x0, 0xcf, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xef, 0xff, 0x60, 0x0, 0xcf, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x25, 0xaf, + 0xff, 0xfd, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd1, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xa6, 0x10, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0x44, 0x44, 0x45, + 0x7d, 0xff, 0xfc, 0x30, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0xcf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0xcf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xf4, 0x0, 0x0, 0xcf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xfe, 0x0, 0x0, 0xcf, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x90, 0x0, + 0xcf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf3, 0x0, 0xcf, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xfd, 0x0, 0xcf, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x70, 0xcf, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf2, + + /* U+0053 "S" */ + 0x0, 0x0, 0x0, 0x5, 0x9c, 0xef, 0xfe, 0xd9, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x20, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xd9, 0x65, 0x56, 0x8c, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x6f, 0xff, 0xe4, 0x0, 0x0, 0x0, 0x0, + 0x3d, 0xff, 0xfb, 0x0, 0x0, 0xcf, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0x20, + 0x0, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0x70, 0x1, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xa0, + 0x0, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0x54, 0x20, 0x0, 0xbf, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xfc, 0x61, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xc8, 0x41, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6e, 0xff, 0xff, 0xff, 0xff, 0xd9, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x8e, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xb3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x37, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x36, 0xae, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3a, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf2, + 0x4, 0x57, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf6, 0x1f, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf8, + 0xf, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xf8, 0xb, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf6, + 0x5, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xf1, 0x0, 0xbf, 0xff, 0xfa, + 0x20, 0x0, 0x0, 0x0, 0x5, 0xef, 0xff, 0xa0, + 0x0, 0x1d, 0xff, 0xff, 0xfd, 0x96, 0x66, 0x7a, + 0xef, 0xff, 0xfd, 0x10, 0x0, 0x1, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0x7, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0x8b, 0xde, 0xff, 0xec, 0x95, 0x0, 0x0, 0x0, + + /* U+0054 "T" */ + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x2f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x5, 0x55, 0x55, 0x55, + 0x55, 0xcf, 0xff, 0x65, 0x55, 0x55, 0x55, 0x53, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + + /* U+0055 "U" */ + 0xdf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xbd, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfb, 0xdf, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xbd, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xfb, 0xdf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xbd, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xfb, 0xdf, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xbd, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xfb, 0xdf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xbd, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xfb, 0xdf, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xbd, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xfb, 0xdf, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xbd, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xfb, 0xdf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xbc, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfb, + 0xcf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xab, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfa, 0xaf, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x98, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf7, 0x5f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0x41, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xf1, 0xb, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, + 0x0, 0x4f, 0xff, 0xfb, 0x20, 0x0, 0x0, 0x0, + 0x2b, 0xff, 0xff, 0x30, 0x0, 0xaf, 0xff, 0xff, + 0xc8, 0x76, 0x79, 0xcf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x7e, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x5, 0x9c, 0xef, 0xff, 0xeb, 0x83, 0x0, + 0x0, 0x0, + + /* U+0056 "V" */ + 0x9f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0x33, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xc0, 0xc, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf6, + 0x0, 0x6f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x0, 0x0, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x90, 0x0, 0x9, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf2, + 0x0, 0x0, 0x3f, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xfc, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x60, 0x0, 0x0, 0x6, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0xf, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xe0, + 0x0, 0x0, 0x6, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x50, 0x0, 0x0, + 0xcf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xfb, 0x0, 0x0, 0x2f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf1, 0x0, 0x8, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x60, 0x0, + 0xef, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xfc, 0x0, 0x4f, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf2, 0x9, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0x70, + 0xef, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xfd, 0x4f, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xfb, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0057 "W" */ + 0x7f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf1, 0x3f, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0xe, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0x80, 0xa, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xef, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x40, 0x5, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0x8e, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x0, 0x1, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0x4a, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xfb, 0x0, 0x0, 0xdf, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x5, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf6, 0x0, 0x0, 0x8f, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x8f, 0xfb, 0x1, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf2, 0x0, + 0x0, 0x4f, 0xff, 0x50, 0x0, 0x0, 0x0, 0xdf, + 0xf6, 0x0, 0xcf, 0xfa, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xd0, 0x0, 0x0, 0xf, 0xff, 0x80, 0x0, + 0x0, 0x2, 0xff, 0xf2, 0x0, 0x8f, 0xfe, 0x0, + 0x0, 0x0, 0xf, 0xff, 0x90, 0x0, 0x0, 0xb, + 0xff, 0xc0, 0x0, 0x0, 0x6, 0xff, 0xd0, 0x0, + 0x3f, 0xff, 0x30, 0x0, 0x0, 0x3f, 0xff, 0x40, + 0x0, 0x0, 0x7, 0xff, 0xf0, 0x0, 0x0, 0xb, + 0xff, 0x90, 0x0, 0xe, 0xff, 0x80, 0x0, 0x0, + 0x7f, 0xff, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf4, + 0x0, 0x0, 0xf, 0xff, 0x40, 0x0, 0xa, 0xff, + 0xc0, 0x0, 0x0, 0xbf, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xf8, 0x0, 0x0, 0x4f, 0xff, 0x0, + 0x0, 0x6, 0xff, 0xf1, 0x0, 0x0, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfb, 0x0, 0x0, + 0x9f, 0xfb, 0x0, 0x0, 0x1, 0xff, 0xf5, 0x0, + 0x3, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x0, 0x0, 0xdf, 0xf6, 0x0, 0x0, 0x0, + 0xdf, 0xf9, 0x0, 0x7, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x30, 0x2, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x8f, 0xfe, 0x0, 0xb, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0x70, + 0x7, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x20, 0xf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xa0, 0xb, 0xff, 0x90, 0x0, 0x0, + 0x0, 0xf, 0xff, 0x60, 0x3f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xe0, 0xf, 0xff, + 0x40, 0x0, 0x0, 0x0, 0xa, 0xff, 0xa0, 0x7f, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf2, 0x3f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xd0, 0xbf, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xf5, 0x7f, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xf0, 0xef, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf8, 0xbf, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf5, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xfc, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xfc, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, + + /* U+0058 "X" */ + 0x2, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xf4, 0x0, 0x6, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf7, 0x0, 0x0, 0xb, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xa0, 0x0, + 0x0, 0x8f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0x60, 0x0, 0x4f, 0xff, + 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0x20, 0x1e, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfc, + 0xb, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xfc, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf9, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf6, 0xc, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xfb, 0x0, 0x2f, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xfe, 0x10, 0x0, + 0x6f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x40, 0x0, 0x0, 0xaf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x80, 0x0, 0x0, 0x1, 0xef, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x3f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfd, + 0x0, 0x0, 0x1d, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf9, 0x0, 0xa, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf5, 0x7, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xe1, + + /* U+0059 "Y" */ + 0x8f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xfe, 0x10, 0xdf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0x50, 0x3, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x90, + 0x0, 0x7, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x0, 0xc, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xb0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0x60, 0x0, 0x0, 0xcf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x10, + 0x0, 0x6f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xfb, 0x0, 0x1f, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xf4, 0xb, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xd5, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+005A "Z" */ + 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe0, 0x0, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe0, 0x0, 0x35, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x56, 0xef, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1d, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfe, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf9, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x51, 0x4f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf5, 0x4f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + + /* U+005B "[" */ + 0x5f, 0xff, 0xff, 0xff, 0x65, 0xff, 0xff, 0xff, + 0xf6, 0x5f, 0xff, 0xee, 0xee, 0x55, 0xff, 0xf2, + 0x0, 0x0, 0x5f, 0xff, 0x20, 0x0, 0x5, 0xff, + 0xf2, 0x0, 0x0, 0x5f, 0xff, 0x20, 0x0, 0x5, + 0xff, 0xf2, 0x0, 0x0, 0x5f, 0xff, 0x20, 0x0, + 0x5, 0xff, 0xf2, 0x0, 0x0, 0x5f, 0xff, 0x20, + 0x0, 0x5, 0xff, 0xf2, 0x0, 0x0, 0x5f, 0xff, + 0x20, 0x0, 0x5, 0xff, 0xf2, 0x0, 0x0, 0x5f, + 0xff, 0x20, 0x0, 0x5, 0xff, 0xf2, 0x0, 0x0, + 0x5f, 0xff, 0x20, 0x0, 0x5, 0xff, 0xf2, 0x0, + 0x0, 0x5f, 0xff, 0x20, 0x0, 0x5, 0xff, 0xf2, + 0x0, 0x0, 0x5f, 0xff, 0x20, 0x0, 0x5, 0xff, + 0xf2, 0x0, 0x0, 0x5f, 0xff, 0x20, 0x0, 0x5, + 0xff, 0xf2, 0x0, 0x0, 0x5f, 0xff, 0x20, 0x0, + 0x5, 0xff, 0xf2, 0x0, 0x0, 0x5f, 0xff, 0x20, + 0x0, 0x5, 0xff, 0xf2, 0x0, 0x0, 0x5f, 0xff, + 0x20, 0x0, 0x5, 0xff, 0xf2, 0x0, 0x0, 0x5f, + 0xff, 0x20, 0x0, 0x5, 0xff, 0xf2, 0x0, 0x0, + 0x5f, 0xff, 0x20, 0x0, 0x5, 0xff, 0xfe, 0xee, + 0xe5, 0x5f, 0xff, 0xff, 0xff, 0x65, 0xff, 0xff, + 0xff, 0xf6, + + /* U+005C "\\" */ + 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0x20, 0x0, 0x0, 0x0, 0x5, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x1, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0xe, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x4, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x3, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0xf, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x7, 0xff, 0x50, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf0, + + /* U+005D "]" */ + 0x4f, 0xff, 0xff, 0xff, 0x74, 0xff, 0xff, 0xff, + 0xf7, 0x4e, 0xee, 0xef, 0xff, 0x70, 0x0, 0x1, + 0xff, 0xf7, 0x0, 0x0, 0x1f, 0xff, 0x70, 0x0, + 0x1, 0xff, 0xf7, 0x0, 0x0, 0x1f, 0xff, 0x70, + 0x0, 0x1, 0xff, 0xf7, 0x0, 0x0, 0x1f, 0xff, + 0x70, 0x0, 0x1, 0xff, 0xf7, 0x0, 0x0, 0x1f, + 0xff, 0x70, 0x0, 0x1, 0xff, 0xf7, 0x0, 0x0, + 0x1f, 0xff, 0x70, 0x0, 0x1, 0xff, 0xf7, 0x0, + 0x0, 0x1f, 0xff, 0x70, 0x0, 0x1, 0xff, 0xf7, + 0x0, 0x0, 0x1f, 0xff, 0x70, 0x0, 0x1, 0xff, + 0xf7, 0x0, 0x0, 0x1f, 0xff, 0x70, 0x0, 0x1, + 0xff, 0xf7, 0x0, 0x0, 0x1f, 0xff, 0x70, 0x0, + 0x1, 0xff, 0xf7, 0x0, 0x0, 0x1f, 0xff, 0x70, + 0x0, 0x1, 0xff, 0xf7, 0x0, 0x0, 0x1f, 0xff, + 0x70, 0x0, 0x1, 0xff, 0xf7, 0x0, 0x0, 0x1f, + 0xff, 0x70, 0x0, 0x1, 0xff, 0xf7, 0x0, 0x0, + 0x1f, 0xff, 0x70, 0x0, 0x1, 0xff, 0xf7, 0x0, + 0x0, 0x1f, 0xff, 0x70, 0x0, 0x1, 0xff, 0xf7, + 0x0, 0x0, 0x1f, 0xff, 0x74, 0xee, 0xee, 0xff, + 0xf7, 0x4f, 0xff, 0xff, 0xff, 0x74, 0xff, 0xff, + 0xff, 0xf7, + + /* U+005E "^" */ + 0x0, 0x0, 0x0, 0x18, 0x87, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xef, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xe3, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf8, 0xc, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x20, + 0x5f, 0xfe, 0x0, 0x0, 0x0, 0x9, 0xff, 0xb0, + 0x0, 0xef, 0xf5, 0x0, 0x0, 0x1, 0xff, 0xf4, + 0x0, 0x8, 0xff, 0xc0, 0x0, 0x0, 0x7f, 0xfe, + 0x0, 0x0, 0x1f, 0xff, 0x40, 0x0, 0xe, 0xff, + 0x70, 0x0, 0x0, 0xbf, 0xfb, 0x0, 0x6, 0xff, + 0xf1, 0x0, 0x0, 0x4, 0xff, 0xf2, 0x0, 0xdf, + 0xfa, 0x0, 0x0, 0x0, 0xd, 0xff, 0x90, 0x4f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x1b, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf7, + + /* U+005F "_" */ + 0x18, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, + 0x88, 0x88, 0x88, 0x83, 0x3f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf7, + + /* U+0060 "`" */ + 0x6, 0x66, 0x63, 0x0, 0x0, 0x8f, 0xff, 0xd0, + 0x0, 0x0, 0xaf, 0xff, 0x60, 0x0, 0x0, 0xcf, + 0xfd, 0x0, 0x0, 0x1, 0xef, 0xf5, 0x0, 0x0, + 0x3, 0xff, 0xd0, + + /* U+0061 "a" */ + 0x0, 0x0, 0x3, 0x8b, 0xef, 0xff, 0xdb, 0x71, + 0x0, 0x0, 0x0, 0x1, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x2e, 0xff, 0xff, + 0xfe, 0xef, 0xff, 0xff, 0xf7, 0x0, 0x0, 0xdf, + 0xff, 0xa3, 0x0, 0x0, 0x3a, 0xff, 0xff, 0x0, + 0x5, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0x40, 0xa, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0x60, 0x3, 0x68, 0x60, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x36, 0x9c, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x16, 0xad, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x19, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0xaf, 0xff, 0x80, 0x2, 0xef, + 0xff, 0xff, 0xdb, 0x85, 0x20, 0xf, 0xff, 0x80, + 0xc, 0xff, 0xfc, 0x51, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x80, 0x3f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0x80, 0x6f, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0x80, 0x7f, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x80, + 0x5f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0x90, 0xf, 0xff, 0xf9, 0x10, 0x0, 0x5, + 0xdf, 0xff, 0xff, 0xa0, 0x6, 0xff, 0xff, 0xfd, + 0xcd, 0xff, 0xff, 0xed, 0xff, 0xb0, 0x0, 0x7f, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x18, 0xff, 0xf0, + 0x0, 0x2, 0x8c, 0xef, 0xfd, 0xb7, 0x10, 0x3, + 0xff, 0xf6, + + /* U+0062 "b" */ + 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xf3, 0x2, 0x9d, 0xff, + 0xd9, 0x30, 0x0, 0x0, 0x4f, 0xff, 0x38, 0xff, + 0xff, 0xff, 0xff, 0xa1, 0x0, 0x4, 0xff, 0xfb, + 0xff, 0xff, 0xef, 0xff, 0xff, 0xd1, 0x0, 0x4f, + 0xff, 0xff, 0xd4, 0x0, 0x3, 0xcf, 0xff, 0xb0, + 0x4, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x60, 0x4f, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xfd, 0x4, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf2, 0x4f, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x64, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf9, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xa4, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xfa, 0x4f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0x94, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xf8, 0x4f, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x54, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf1, 0x4f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xfb, 0x4, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x30, 0x4f, 0xff, 0xff, 0xc4, + 0x0, 0x4, 0xdf, 0xff, 0x80, 0x4, 0xff, 0xf9, + 0xff, 0xff, 0xef, 0xff, 0xff, 0xa0, 0x0, 0x4f, + 0xff, 0x9, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x4, 0xff, 0xf0, 0x3, 0xad, 0xfe, 0xc8, 0x20, + 0x0, 0x0, + + /* U+0063 "c" */ + 0x0, 0x0, 0x0, 0x6b, 0xdf, 0xfe, 0xb6, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xef, 0xff, 0xff, 0xff, + 0xfe, 0x50, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfe, + 0xef, 0xff, 0xff, 0x70, 0x0, 0x7, 0xff, 0xff, + 0x71, 0x0, 0x17, 0xff, 0xff, 0x30, 0x2, 0xff, + 0xfe, 0x20, 0x0, 0x0, 0x4, 0xff, 0xfb, 0x0, + 0x9f, 0xff, 0x40, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf1, 0xe, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x4c, 0xa8, 0x12, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xba, 0x84, 0xe, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x60, 0x8f, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf2, + 0x2, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x3, 0xff, + 0xfb, 0x0, 0x7, 0xff, 0xfd, 0x50, 0x0, 0x16, + 0xff, 0xff, 0x20, 0x0, 0x9, 0xff, 0xff, 0xfe, + 0xef, 0xff, 0xff, 0x40, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, + 0x1, 0x6b, 0xdf, 0xfe, 0xa5, 0x0, 0x0, 0x0, + + /* U+0064 "d" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x70, 0x0, 0x0, 0x38, 0xde, 0xfd, + 0xa3, 0x1, 0xff, 0xf7, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xf9, 0x1f, 0xff, 0x70, 0x0, 0xbf, + 0xff, 0xff, 0xef, 0xff, 0xfb, 0xff, 0xf7, 0x0, + 0x9f, 0xff, 0xd4, 0x0, 0x3, 0xcf, 0xff, 0xff, + 0x70, 0x3f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf7, 0xa, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0x70, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xf7, 0x3f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x76, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf7, + 0x7f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0x78, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xf7, 0x7f, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0x76, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xf7, 0x3f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x70, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xf7, 0x9, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x70, 0x2f, 0xff, 0xd1, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xf7, 0x0, 0x7f, 0xff, 0xe5, + 0x0, 0x3, 0xbf, 0xff, 0xff, 0x70, 0x0, 0x9f, + 0xff, 0xff, 0xef, 0xff, 0xfb, 0xdf, 0xf7, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0xfb, 0xd, 0xff, + 0x70, 0x0, 0x0, 0x17, 0xce, 0xfe, 0xb5, 0x0, + 0xdf, 0xf7, + + /* U+0065 "e" */ + 0x0, 0x0, 0x0, 0x5a, 0xde, 0xfe, 0xb7, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x4d, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xfe, 0xef, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x4f, + 0xff, 0xf7, 0x10, 0x0, 0x4c, 0xff, 0xfa, 0x0, + 0x0, 0xef, 0xfe, 0x20, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0x50, 0x7, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xc0, 0xd, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf2, 0x1f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf6, + 0x4f, 0xff, 0xed, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xff, 0xf8, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x6f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x6f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x10, 0x0, 0xe, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xd5, 0x8, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf2, + 0x1, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xa0, 0x0, 0x6f, 0xff, 0xf9, 0x20, 0x0, + 0x3b, 0xff, 0xfe, 0x10, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xef, 0xff, 0xff, 0xe3, 0x0, 0x0, 0x0, + 0x5e, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x5a, 0xde, 0xfe, 0xd9, 0x30, + 0x0, 0x0, + + /* U+0066 "f" */ + 0x0, 0x0, 0x3, 0x9d, 0xff, 0xec, 0x40, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x2, 0xff, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x6f, 0xff, 0xc5, + 0x34, 0x40, 0x0, 0x8, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xe0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x0, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xf0, 0x7, 0xbb, 0xdf, 0xff, 0xbb, 0xba, + 0x0, 0x0, 0x9, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xfe, 0x0, 0x0, 0x0, + + /* U+0067 "g" */ + 0x0, 0x0, 0x2, 0x8c, 0xef, 0xea, 0x50, 0x9, + 0xff, 0xa0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, + 0xb1, 0x9f, 0xfa, 0x0, 0xb, 0xff, 0xff, 0xfe, + 0xff, 0xff, 0xdb, 0xff, 0xa0, 0x9, 0xff, 0xfd, + 0x50, 0x0, 0x3b, 0xff, 0xff, 0xfa, 0x3, 0xff, + 0xfd, 0x10, 0x0, 0x0, 0x9, 0xff, 0xff, 0xa0, + 0xaf, 0xff, 0x20, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xfa, 0xf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xa4, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xfa, 0x7f, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xa8, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfa, 0x9f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xa9, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xfa, 0x7f, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xa4, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xfa, 0x1f, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xa0, 0xaf, + 0xff, 0x20, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfa, + 0x3, 0xff, 0xfc, 0x10, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xa0, 0x8, 0xff, 0xfd, 0x50, 0x0, 0x3a, + 0xff, 0xff, 0xfa, 0x0, 0xb, 0xff, 0xff, 0xfe, + 0xff, 0xff, 0xcf, 0xff, 0xa0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0xff, 0xb1, 0xff, 0xf9, 0x0, 0x0, + 0x2, 0x8c, 0xef, 0xea, 0x40, 0xf, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf7, 0x4, 0x31, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x40, 0xdf, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xf1, 0xa, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xfb, 0x0, 0x4f, 0xff, + 0xd5, 0x0, 0x0, 0x28, 0xff, 0xff, 0x20, 0x0, + 0xaf, 0xff, 0xff, 0xee, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x30, 0x0, 0x0, 0x0, 0x27, 0xbe, 0xff, 0xfd, + 0x94, 0x0, 0x0, 0x0, + + /* U+0068 "h" */ + 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x30, 0x17, 0xce, 0xfe, 0xc8, 0x10, 0x0, + 0x4f, 0xff, 0x35, 0xef, 0xff, 0xff, 0xff, 0xf6, + 0x0, 0x4f, 0xff, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x40, 0x4f, 0xff, 0xff, 0xe7, 0x20, 0x4, + 0xcf, 0xff, 0xd0, 0x4f, 0xff, 0xfc, 0x10, 0x0, + 0x0, 0xd, 0xff, 0xf2, 0x4f, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xf6, 0x4f, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf8, 0x4f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf9, 0x4f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf9, + 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xf9, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xf9, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xf9, 0x4f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xf9, 0x4f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xf9, 0x4f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xf9, 0x4f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf9, 0x4f, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf9, + 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xf9, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xf9, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xf9, 0x4f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xf9, + + /* U+0069 "i" */ + 0x5f, 0xff, 0x35, 0xff, 0xf3, 0x5f, 0xff, 0x35, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf3, 0x5f, 0xff, 0x35, 0xff, + 0xf3, 0x5f, 0xff, 0x35, 0xff, 0xf3, 0x5f, 0xff, + 0x35, 0xff, 0xf3, 0x5f, 0xff, 0x35, 0xff, 0xf3, + 0x5f, 0xff, 0x35, 0xff, 0xf3, 0x5f, 0xff, 0x35, + 0xff, 0xf3, 0x5f, 0xff, 0x35, 0xff, 0xf3, 0x5f, + 0xff, 0x35, 0xff, 0xf3, 0x5f, 0xff, 0x35, 0xff, + 0xf3, 0x5f, 0xff, 0x35, 0xff, 0xf3, + + /* U+006A "j" */ + 0x0, 0x0, 0x4f, 0xff, 0x30, 0x0, 0x4, 0xff, + 0xf3, 0x0, 0x0, 0x4f, 0xff, 0x30, 0x0, 0x4, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf3, 0x0, 0x0, 0x4f, 0xff, + 0x30, 0x0, 0x4, 0xff, 0xf3, 0x0, 0x0, 0x4f, + 0xff, 0x30, 0x0, 0x4, 0xff, 0xf3, 0x0, 0x0, + 0x4f, 0xff, 0x30, 0x0, 0x4, 0xff, 0xf3, 0x0, + 0x0, 0x4f, 0xff, 0x30, 0x0, 0x4, 0xff, 0xf3, + 0x0, 0x0, 0x4f, 0xff, 0x30, 0x0, 0x4, 0xff, + 0xf3, 0x0, 0x0, 0x4f, 0xff, 0x30, 0x0, 0x4, + 0xff, 0xf3, 0x0, 0x0, 0x4f, 0xff, 0x30, 0x0, + 0x4, 0xff, 0xf3, 0x0, 0x0, 0x4f, 0xff, 0x30, + 0x0, 0x4, 0xff, 0xf3, 0x0, 0x0, 0x4f, 0xff, + 0x30, 0x0, 0x4, 0xff, 0xf3, 0x0, 0x0, 0x4f, + 0xff, 0x30, 0x0, 0x4, 0xff, 0xf3, 0x0, 0x0, + 0x4f, 0xff, 0x30, 0x0, 0x5, 0xff, 0xf2, 0x0, + 0x0, 0x6f, 0xff, 0x20, 0x0, 0x8, 0xff, 0xf0, + 0x2, 0x14, 0xef, 0xfc, 0x4, 0xff, 0xff, 0xff, + 0x70, 0x8f, 0xff, 0xff, 0xd0, 0x8, 0xef, 0xfd, + 0x80, 0x0, + + /* U+006B "k" */ + 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0x20, 0x0, 0x0, 0x1, 0xdf, 0xff, 0x80, + 0x5f, 0xff, 0x20, 0x0, 0x0, 0x1d, 0xff, 0xf8, + 0x0, 0x5f, 0xff, 0x20, 0x0, 0x1, 0xdf, 0xff, + 0x80, 0x0, 0x5f, 0xff, 0x20, 0x0, 0x1d, 0xff, + 0xf7, 0x0, 0x0, 0x5f, 0xff, 0x20, 0x1, 0xdf, + 0xff, 0x70, 0x0, 0x0, 0x5f, 0xff, 0x20, 0xc, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x20, + 0xcf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x3c, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xdf, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0x9f, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xf6, 0x8, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, 0xdf, + 0xff, 0x30, 0x0, 0x0, 0x5f, 0xff, 0x20, 0x0, + 0x4f, 0xff, 0xd0, 0x0, 0x0, 0x5f, 0xff, 0x20, + 0x0, 0xa, 0xff, 0xf8, 0x0, 0x0, 0x5f, 0xff, + 0x20, 0x0, 0x1, 0xef, 0xff, 0x30, 0x0, 0x5f, + 0xff, 0x20, 0x0, 0x0, 0x5f, 0xff, 0xd0, 0x0, + 0x5f, 0xff, 0x20, 0x0, 0x0, 0xb, 0xff, 0xf8, + 0x0, 0x5f, 0xff, 0x20, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x30, 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xd0, 0x5f, 0xff, 0x20, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf8, + + /* U+006C "l" */ + 0x5f, 0xff, 0x25, 0xff, 0xf2, 0x5f, 0xff, 0x25, + 0xff, 0xf2, 0x5f, 0xff, 0x25, 0xff, 0xf2, 0x5f, + 0xff, 0x25, 0xff, 0xf2, 0x5f, 0xff, 0x25, 0xff, + 0xf2, 0x5f, 0xff, 0x25, 0xff, 0xf2, 0x5f, 0xff, + 0x25, 0xff, 0xf2, 0x5f, 0xff, 0x25, 0xff, 0xf2, + 0x5f, 0xff, 0x25, 0xff, 0xf2, 0x5f, 0xff, 0x25, + 0xff, 0xf2, 0x5f, 0xff, 0x25, 0xff, 0xf2, 0x5f, + 0xff, 0x25, 0xff, 0xf2, 0x5f, 0xff, 0x25, 0xff, + 0xf2, 0x5f, 0xff, 0x25, 0xff, 0xf2, + + /* U+006D "m" */ + 0x6f, 0xfc, 0x0, 0x28, 0xde, 0xfd, 0xa3, 0x0, + 0x0, 0x6, 0xce, 0xfe, 0xb6, 0x0, 0x6, 0xff, + 0xc0, 0x7f, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x3e, + 0xff, 0xff, 0xff, 0xfc, 0x10, 0x6f, 0xfc, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0xf5, 0x3f, 0xff, 0xff, + 0xff, 0xff, 0xfa, 0x6, 0xff, 0xff, 0xfc, 0x51, + 0x3, 0xbf, 0xff, 0xde, 0xfe, 0x61, 0x1, 0x7f, + 0xff, 0xf2, 0x6f, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x7f, 0xff, + 0x76, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x1, 0xff, 0xf9, 0x6f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xb6, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xfb, 0x6f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xb6, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xfb, 0x6f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x70, 0x0, 0x0, 0x0, 0xc, 0xff, 0xb6, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfb, 0x6f, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x70, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xb6, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xfb, 0x6f, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x70, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xb6, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfb, + 0x6f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0xc, 0xff, 0xb6, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xfb, 0x6f, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xb6, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xfb, 0x6f, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x70, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xb0, + + /* U+006E "n" */ + 0x4f, 0xfe, 0x0, 0x17, 0xce, 0xfe, 0xc7, 0x10, + 0x0, 0x4f, 0xfe, 0x5, 0xef, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0x4f, 0xfe, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x40, 0x4f, 0xff, 0xff, 0xe6, 0x20, + 0x14, 0xcf, 0xff, 0xe0, 0x4f, 0xff, 0xfc, 0x10, + 0x0, 0x0, 0xd, 0xff, 0xf3, 0x4f, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf6, 0x4f, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf8, 0x4f, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf8, + 0x4f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf9, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf9, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf9, 0x4f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf9, 0x4f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xf9, 0x4f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf9, 0x4f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf9, 0x4f, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf9, + 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf9, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf9, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf9, 0x4f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf9, 0x4f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xf9, + + /* U+006F "o" */ + 0x0, 0x0, 0x0, 0x5a, 0xdf, 0xfe, 0xb7, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x5e, 0xff, 0xff, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xef, 0xff, 0xff, 0xc1, 0x0, 0x0, 0x9f, + 0xff, 0xf7, 0x10, 0x0, 0x5d, 0xff, 0xfb, 0x0, + 0x3, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x70, 0xb, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xe0, 0x1f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf4, 0x4f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf8, + 0x7f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xfb, 0x8f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xfc, 0x9f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfd, 0x8f, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfc, + 0x7f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xfa, 0x4f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xf8, 0xf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf4, 0xb, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xe0, + 0x3, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x70, 0x0, 0x8f, 0xff, 0xf7, 0x10, 0x0, + 0x5d, 0xff, 0xfc, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xfe, 0xef, 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, + 0x6e, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6a, 0xdf, 0xfe, 0xb7, 0x10, + 0x0, 0x0, + + /* U+0070 "p" */ + 0x4f, 0xfe, 0x0, 0x39, 0xdf, 0xfd, 0x94, 0x0, + 0x0, 0x4, 0xff, 0xe0, 0x8f, 0xff, 0xff, 0xff, + 0xfb, 0x10, 0x0, 0x4f, 0xfe, 0x8f, 0xff, 0xdc, + 0xdf, 0xff, 0xfd, 0x10, 0x4, 0xff, 0xff, 0xfd, + 0x30, 0x0, 0x1b, 0xff, 0xfc, 0x0, 0x4f, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf6, 0x4, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xd0, 0x4f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x34, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf7, 0x4f, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x94, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfa, 0x4f, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xb4, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf9, 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0x84, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf5, 0x4f, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x14, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xb0, + 0x4f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf3, 0x4, 0xff, 0xff, 0xfb, 0x30, 0x0, 0x5d, + 0xff, 0xf9, 0x0, 0x4f, 0xff, 0xdf, 0xff, 0xfe, + 0xff, 0xff, 0xfa, 0x0, 0x4, 0xff, 0xf4, 0x9f, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x4f, 0xff, + 0x30, 0x4a, 0xef, 0xec, 0x82, 0x0, 0x0, 0x4, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0071 "q" */ + 0x0, 0x0, 0x2, 0x8d, 0xef, 0xda, 0x40, 0xb, + 0xff, 0x70, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, + 0xa0, 0xbf, 0xf7, 0x0, 0xb, 0xff, 0xff, 0xdc, + 0xdf, 0xff, 0xbb, 0xff, 0x70, 0x9, 0xff, 0xfc, + 0x20, 0x0, 0x2b, 0xff, 0xff, 0xf7, 0x3, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x70, + 0xaf, 0xff, 0x20, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xf7, 0xf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x73, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xf7, 0x6f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0x77, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf7, 0x7f, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0x76, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xf7, 0x5f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0x72, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xf7, 0xe, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x70, 0x7f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf7, + 0x1, 0xef, 0xfe, 0x20, 0x0, 0x0, 0x8, 0xff, + 0xff, 0x70, 0x5, 0xff, 0xfe, 0x60, 0x0, 0x2b, + 0xff, 0xff, 0xf7, 0x0, 0x7, 0xff, 0xff, 0xfe, + 0xef, 0xff, 0xdf, 0xff, 0x70, 0x0, 0x6, 0xef, + 0xff, 0xff, 0xff, 0xb2, 0xff, 0xf7, 0x0, 0x0, + 0x1, 0x7c, 0xef, 0xea, 0x40, 0x1f, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x70, + + /* U+0072 "r" */ + 0x6f, 0xfc, 0x0, 0x7d, 0xfd, 0xa5, 0x6f, 0xfc, + 0xb, 0xff, 0xff, 0xf9, 0x6f, 0xfc, 0x9f, 0xff, + 0xff, 0xf4, 0x6f, 0xfe, 0xff, 0xea, 0xad, 0xe0, + 0x6f, 0xff, 0xfb, 0x0, 0x0, 0x20, 0x6f, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x10, 0x0, 0x0, 0x0, + + /* U+0073 "s" */ + 0x0, 0x0, 0x4a, 0xdf, 0xff, 0xda, 0x50, 0x0, + 0x0, 0x0, 0x2c, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x50, 0x0, 0x1, 0xef, 0xff, 0xff, 0xef, 0xff, + 0xff, 0xf6, 0x0, 0xa, 0xff, 0xf8, 0x20, 0x0, + 0x18, 0xff, 0xff, 0x0, 0xf, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x60, 0x2f, 0xff, 0x40, + 0x0, 0x0, 0x0, 0xf, 0xfd, 0x60, 0x1f, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xfc, 0x51, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0xc7, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xfe, 0xa4, + 0x0, 0x0, 0x0, 0x2, 0x9f, 0xff, 0xff, 0xff, + 0xff, 0xd5, 0x0, 0x0, 0x0, 0x0, 0x48, 0xcf, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x5a, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1c, 0xff, 0xf4, 0x6a, 0xdc, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf6, 0x8f, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf5, + 0x2f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf1, 0xa, 0xff, 0xfc, 0x40, 0x0, 0x3, 0xbf, + 0xff, 0xa0, 0x1, 0xdf, 0xff, 0xff, 0xee, 0xff, + 0xff, 0xfd, 0x10, 0x0, 0x1a, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xa1, 0x0, 0x0, 0x0, 0x28, 0xce, + 0xff, 0xec, 0x82, 0x0, 0x0, + + /* U+0074 "t" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7a, 0x0, 0x0, 0x0, 0x3, 0xdf, 0xb0, 0x0, + 0x0, 0x0, 0xcf, 0xfb, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0xcf, 0xfb, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0xcf, 0xfb, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0x45, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x4b, + 0xbe, 0xff, 0xeb, 0xbb, 0x20, 0x0, 0xcf, 0xfb, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0xcf, 0xfb, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0xcf, 0xfb, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xb0, 0x0, 0x0, 0x0, 0xcf, + 0xfb, 0x0, 0x0, 0x0, 0xc, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0xcf, 0xfb, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0xcf, 0xfb, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0xcf, 0xfb, 0x0, 0x0, 0x0, 0xb, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0x94, 0x41, 0x0, + 0x6, 0xff, 0xff, 0xff, 0x60, 0x0, 0xd, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x18, 0xdf, 0xfe, 0x80, + + /* U+0075 "u" */ + 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xf7, 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xf7, 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xf7, 0x5f, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xf7, 0x5f, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xf7, 0x5f, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xf7, 0x5f, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf7, 0x5f, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf7, + 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xf7, 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xf7, 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xf7, 0x5f, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xf7, 0x5f, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xf7, 0x5f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf7, 0x4f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf7, 0x2f, + 0xff, 0x80, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf7, + 0xf, 0xff, 0xe2, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xf7, 0xa, 0xff, 0xfe, 0x62, 0x1, 0x5c, 0xff, + 0xef, 0xf7, 0x1, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xf7, 0xbf, 0xf7, 0x0, 0x2d, 0xff, 0xff, 0xff, + 0xff, 0x60, 0xbf, 0xf7, 0x0, 0x0, 0x6b, 0xef, + 0xec, 0x71, 0x0, 0xbf, 0xf7, + + /* U+0076 "v" */ + 0x4f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf5, 0xe, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xe0, 0x8, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x90, 0x2, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x30, + 0x0, 0xcf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xfd, 0x0, 0x0, 0x6f, 0xff, 0x20, 0x0, 0x0, + 0x1, 0xff, 0xf7, 0x0, 0x0, 0x1f, 0xff, 0x80, + 0x0, 0x0, 0x6, 0xff, 0xf1, 0x0, 0x0, 0xa, + 0xff, 0xd0, 0x0, 0x0, 0xc, 0xff, 0xb0, 0x0, + 0x0, 0x4, 0xff, 0xf3, 0x0, 0x0, 0x2f, 0xff, + 0x50, 0x0, 0x0, 0x0, 0xef, 0xf9, 0x0, 0x0, + 0x7f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfe, + 0x0, 0x0, 0xdf, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x40, 0x3, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xa0, 0x9, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf0, 0xe, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xf4, 0x4f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xf9, 0x9f, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xfe, 0xef, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfd, 0x0, 0x0, + 0x0, 0x0, + + /* U+0077 "w" */ + 0xaf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0xe, 0xff, 0x75, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf3, 0x1f, 0xff, 0x80, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x7f, 0xfe, 0x0, 0xbf, 0xfc, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0x30, 0x0, 0x0, 0xc, + 0xff, 0x90, 0x7, 0xff, 0xf1, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x1, 0xff, 0xf4, + 0x0, 0x2f, 0xff, 0x50, 0x0, 0x0, 0xbf, 0xfa, + 0xff, 0xb0, 0x0, 0x0, 0x5f, 0xfe, 0x0, 0x0, + 0xdf, 0xf9, 0x0, 0x0, 0xf, 0xff, 0x3f, 0xff, + 0x0, 0x0, 0xa, 0xff, 0xa0, 0x0, 0x8, 0xff, + 0xd0, 0x0, 0x4, 0xff, 0xb0, 0xff, 0xf4, 0x0, + 0x0, 0xff, 0xf5, 0x0, 0x0, 0x3f, 0xff, 0x20, + 0x0, 0x8f, 0xf7, 0xc, 0xff, 0x80, 0x0, 0x4f, + 0xff, 0x0, 0x0, 0x0, 0xef, 0xf6, 0x0, 0xd, + 0xff, 0x30, 0x8f, 0xfc, 0x0, 0x8, 0xff, 0xb0, + 0x0, 0x0, 0xa, 0xff, 0xa0, 0x1, 0xff, 0xe0, + 0x3, 0xff, 0xf0, 0x0, 0xdf, 0xf6, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x0, 0x5f, 0xfb, 0x0, 0xf, + 0xff, 0x40, 0x2f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0xff, 0xf3, 0x9, 0xff, 0x60, 0x0, 0xbf, 0xf8, + 0x6, 0xff, 0xc0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0x80, 0xdf, 0xf2, 0x0, 0x7, 0xff, 0xc0, 0xbf, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfc, 0x1f, + 0xfe, 0x0, 0x0, 0x3f, 0xff, 0x1f, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xf6, 0xff, 0xa0, + 0x0, 0x0, 0xef, 0xf9, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xef, 0xf6, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0x50, 0x0, 0x0, + 0x0, + + /* U+0078 "x" */ + 0xc, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xc0, 0x2, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x20, 0x0, 0x6f, 0xff, 0xd0, + 0x0, 0x0, 0xc, 0xff, 0xf5, 0x0, 0x0, 0xb, + 0xff, 0xf8, 0x0, 0x0, 0x7f, 0xff, 0x90, 0x0, + 0x0, 0x1, 0xef, 0xff, 0x20, 0x3, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xc0, 0xd, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf6, 0x9f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf7, 0x7f, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xc0, 0xd, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x30, 0x3, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf8, 0x0, 0x0, 0x8f, 0xff, + 0x90, 0x0, 0x0, 0x4f, 0xff, 0xd0, 0x0, 0x0, + 0xd, 0xff, 0xf4, 0x0, 0x1, 0xef, 0xff, 0x30, + 0x0, 0x0, 0x3, 0xff, 0xfe, 0x10, 0xa, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xa0, + 0x5f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf5, + + /* U+0079 "y" */ + 0x2f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xf7, 0xc, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xf1, 0x6, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xb0, 0x1, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x50, + 0x0, 0xaf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x8f, + 0xfe, 0x0, 0x0, 0x4f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0xef, 0xf9, 0x0, 0x0, 0xe, 0xff, 0xc0, + 0x0, 0x0, 0x4, 0xff, 0xf3, 0x0, 0x0, 0x8, + 0xff, 0xf2, 0x0, 0x0, 0xa, 0xff, 0xd0, 0x0, + 0x0, 0x2, 0xff, 0xf8, 0x0, 0x0, 0xf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0xbf, 0xfd, 0x0, 0x0, + 0x5f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x30, 0x0, 0xbf, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0x90, 0x1, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xe0, 0x7, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf3, 0xc, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xf8, 0x2f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xfd, 0x6f, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xdf, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x86, 0x69, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5d, 0xfe, 0xb4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+007A "z" */ + 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x80, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x80, 0x5, 0xcc, 0xcc, 0xcc, + 0xcc, 0xcc, 0xcc, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xef, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1d, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfe, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf2, + + /* U+007B "{" */ + 0x0, 0x0, 0x0, 0x3a, 0xdf, 0xf7, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x6f, 0xff, 0x82, 0x10, + 0x0, 0x0, 0x9f, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0xc, 0xff, 0xb0, + 0x0, 0x0, 0x36, 0xdf, 0xfe, 0x20, 0x0, 0x0, + 0xdf, 0xff, 0xd2, 0x0, 0x0, 0x0, 0xdf, 0xfd, + 0x10, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xe3, 0x0, + 0x0, 0x0, 0x3, 0xaf, 0xff, 0x20, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x82, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x3a, 0xef, 0xf7, + + /* U+007C "|" */ + 0x5f, 0xfb, 0x5f, 0xfb, 0x5f, 0xfb, 0x5f, 0xfb, + 0x5f, 0xfb, 0x5f, 0xfb, 0x5f, 0xfb, 0x5f, 0xfb, + 0x5f, 0xfb, 0x5f, 0xfb, 0x5f, 0xfb, 0x5f, 0xfb, + 0x5f, 0xfb, 0x5f, 0xfb, 0x5f, 0xfb, 0x5f, 0xfb, + 0x5f, 0xfb, 0x5f, 0xfb, 0x5f, 0xfb, 0x5f, 0xfb, + 0x5f, 0xfb, 0x5f, 0xfb, 0x5f, 0xfb, 0x5f, 0xfb, + 0x5f, 0xfb, 0x5f, 0xfb, 0x5f, 0xfb, 0x5f, 0xfb, + 0x5f, 0xfb, 0x5f, 0xfb, 0x5f, 0xfb, 0x5f, 0xfb, + 0x5f, 0xfb, 0x5f, 0xfb, 0x5f, 0xfb, 0x5f, 0xfb, + + /* U+007D "}" */ + 0x1f, 0xfe, 0xc6, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x1, 0x4e, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf8, 0x40, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0x30, 0x0, 0x0, 0xb, 0xff, + 0xe5, 0x10, 0x0, 0x0, 0x4, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x15, 0xef, 0xfb, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x1, 0xff, 0xeb, 0x50, 0x0, + 0x0, 0x0, + + /* U+007E "~" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0x9d, 0xff, 0xda, 0x61, + 0x0, 0x0, 0x0, 0x0, 0x28, 0x8, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x61, 0x0, 0x0, 0x7f, 0xb4, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xab, + 0xff, 0xfb, 0x4f, 0xff, 0xdb, 0xbe, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb4, 0xfb, 0x20, 0x0, + 0x3, 0x8e, 0xff, 0xff, 0xff, 0xff, 0xd2, 0x46, + 0x0, 0x0, 0x0, 0x0, 0x4, 0x9d, 0xff, 0xea, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+00A0 " " */ + + /* U+00A3 "£" */ + 0x0, 0x0, 0x0, 0x2, 0x8c, 0xef, 0xfd, 0xa5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xd4, 0x0, 0x0, 0x0, 0x0, + 0x2e, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xd4, 0x0, 0x2, + 0x9f, 0xff, 0xf3, 0x0, 0x0, 0x7, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xfc, 0x0, 0x0, + 0xc, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0x20, 0x0, 0xf, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0x50, 0x0, 0xf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x10, 0x0, + 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xdd, 0xef, 0xff, 0xed, 0xdd, + 0xdd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfc, + 0xad, 0xdc, 0x95, 0x10, 0x0, 0x0, 0x5, 0x10, + 0x2d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x96, + 0x58, 0xdf, 0x70, 0x1f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0xa, 0xff, + 0xa5, 0x10, 0x3, 0x7c, 0xff, 0xff, 0xff, 0xff, + 0xe1, 0x4, 0xb2, 0x0, 0x0, 0x0, 0x0, 0x16, + 0xae, 0xfe, 0xa5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00A4 "¤" */ + 0x0, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0x0, 0x3, 0xfb, 0x0, 0x0, 0x1, 0x20, + 0x0, 0x0, 0x8f, 0x60, 0x2e, 0xff, 0xb0, 0x5b, + 0xff, 0xff, 0xc7, 0x8, 0xff, 0xf5, 0xb, 0xff, + 0xfe, 0xff, 0xff, 0xff, 0xff, 0xef, 0xff, 0xe2, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x20, 0x0, 0xe, 0xff, 0xfb, 0x40, 0x3, + 0x9f, 0xff, 0xf3, 0x0, 0x0, 0x5f, 0xff, 0x70, + 0x0, 0x0, 0x5, 0xff, 0xf9, 0x0, 0x0, 0xcf, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x0, + 0x0, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x30, 0x1, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0x50, 0x1, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0x50, 0x0, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x30, + 0x0, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xfe, 0x0, 0x0, 0x4f, 0xff, 0xa0, 0x0, 0x0, + 0x7, 0xff, 0xf8, 0x0, 0x0, 0x1e, 0xff, 0xfd, + 0x63, 0x35, 0xcf, 0xff, 0xf3, 0x0, 0x1, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, + 0x1d, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xcf, + 0xff, 0xf3, 0x1d, 0xff, 0x90, 0x29, 0xdf, 0xfe, + 0xa4, 0x5, 0xff, 0xf4, 0x2, 0xe9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0x40, 0x0, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, + + /* U+00A5 "¥" */ + 0xaf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xfd, 0x1, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x40, 0x7, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xb0, 0x0, 0xd, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf2, 0x0, 0x0, 0x4f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0x30, 0x0, 0x0, + 0x2, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf6, 0x0, 0x0, 0x3f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xe0, 0x0, 0xc, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0x80, 0x6, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x20, 0xef, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xfa, 0x7f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x9d, 0xdd, + 0xdd, 0xdf, 0xff, 0xff, 0xfe, 0xdd, 0xdd, 0xdd, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0xb, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x7b, 0xbb, 0xbb, 0xbb, 0xef, 0xff, + 0xbb, 0xbb, 0xbb, 0xba, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+00A6 "¦" */ + 0x5f, 0xfb, 0x5f, 0xfb, 0x5f, 0xfb, 0x5f, 0xfb, + 0x5f, 0xfb, 0x5f, 0xfb, 0x5f, 0xfb, 0x5f, 0xfb, + 0x5f, 0xfb, 0x5f, 0xfb, 0x5f, 0xfb, 0x5f, 0xfb, + 0x5f, 0xfb, 0x5f, 0xfb, 0x5f, 0xfb, 0x14, 0x43, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x14, 0x43, 0x5f, 0xfb, 0x5f, 0xfb, 0x5f, 0xfb, + 0x5f, 0xfb, 0x5f, 0xfb, 0x5f, 0xfb, 0x5f, 0xfb, + 0x5f, 0xfb, 0x5f, 0xfb, 0x5f, 0xfb, 0x5f, 0xfb, + 0x5f, 0xfb, 0x5f, 0xfb, 0x5f, 0xfb, 0x5f, 0xfb, + + /* U+00A7 "§" */ + 0x0, 0x0, 0x0, 0x6b, 0xef, 0xfd, 0xa5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, 0xff, 0xff, + 0xff, 0xd3, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xef, 0xff, 0xff, 0x30, 0x0, 0x0, 0xd, + 0xff, 0xf9, 0x10, 0x1, 0xaf, 0xff, 0xd0, 0x0, + 0x0, 0x3f, 0xff, 0x60, 0x0, 0x0, 0xb, 0xff, + 0xf4, 0x0, 0x0, 0x6f, 0xff, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf9, 0x0, 0x0, 0x6f, 0xff, 0x10, + 0x0, 0x0, 0x0, 0xdc, 0xb7, 0x0, 0x0, 0x2f, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xd3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1a, + 0xff, 0xff, 0xff, 0xfe, 0x60, 0x0, 0x0, 0x0, + 0x1, 0xdf, 0xfc, 0x27, 0xff, 0xff, 0xfc, 0x20, + 0x0, 0x0, 0xb, 0xff, 0xb0, 0x0, 0x2c, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x2f, 0xff, 0x20, 0x0, + 0x0, 0x6e, 0xff, 0xff, 0xc1, 0x0, 0x4f, 0xfe, + 0x0, 0x0, 0x0, 0x1, 0xaf, 0xff, 0xfe, 0x10, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xc0, 0x1f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xf3, 0xb, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf6, 0x2, 0xef, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf7, + 0x0, 0x2e, 0xff, 0xfd, 0x40, 0x0, 0x0, 0x0, + 0xef, 0xf5, 0x0, 0x1, 0xbf, 0xff, 0xfa, 0x10, + 0x0, 0x3, 0xff, 0xf1, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xf6, 0x0, 0x1d, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x1a, 0xff, 0xff, 0xc6, 0xef, 0xd3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4d, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xfe, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xcf, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x22, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x0, 0x0, 0xef, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0x10, 0x0, 0xdf, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0x10, 0x0, 0x7f, + 0xff, 0xa0, 0x0, 0x0, 0x1, 0xef, 0xfd, 0x0, + 0x0, 0x1e, 0xff, 0xfb, 0x30, 0x1, 0x5e, 0xff, + 0xf7, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x3d, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4a, 0xdf, 0xfe, 0xc8, 0x20, 0x0, 0x0, + + /* U+00A8 "¨" */ + 0xcf, 0xfd, 0x0, 0x7, 0xff, 0xf2, 0xdf, 0xfd, + 0x0, 0x8, 0xff, 0xf2, 0xdf, 0xfd, 0x0, 0x8, + 0xff, 0xf2, 0xdf, 0xfd, 0x0, 0x8, 0xff, 0xf2, + + /* U+00A9 "©" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x59, 0xce, 0xff, + 0xec, 0x83, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xfe, 0xa8, 0x77, 0x9c, 0xff, + 0xff, 0xd2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1c, + 0xff, 0xf9, 0x20, 0x0, 0x0, 0x0, 0x16, 0xdf, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xfc, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0xc, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, + 0x40, 0x0, 0x0, 0x8f, 0xf9, 0x0, 0x0, 0x5, + 0xae, 0xff, 0xd9, 0x20, 0x0, 0x2, 0xef, 0xe1, + 0x0, 0x2, 0xff, 0xb0, 0x0, 0x2, 0xdf, 0xff, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x4f, 0xfa, 0x0, + 0xa, 0xff, 0x20, 0x0, 0x1e, 0xff, 0xb5, 0x34, + 0x7e, 0xff, 0x70, 0x0, 0xa, 0xff, 0x20, 0x1f, + 0xf8, 0x0, 0x0, 0xbf, 0xf7, 0x0, 0x0, 0x1, + 0xcf, 0xf2, 0x0, 0x2, 0xff, 0x90, 0x6f, 0xf2, + 0x0, 0x3, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x2f, + 0xe5, 0x0, 0x0, 0xbf, 0xe0, 0xaf, 0xd0, 0x0, + 0x9, 0xff, 0x30, 0x0, 0x0, 0x0, 0x1, 0x0, + 0x0, 0x0, 0x5f, 0xf2, 0xdf, 0xa0, 0x0, 0xc, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xf5, 0xef, 0x80, 0x0, 0xe, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xf6, 0xff, 0x70, 0x0, 0xf, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xf7, 0xff, 0x80, 0x0, 0xe, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf6, + 0xdf, 0x90, 0x0, 0xc, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xf5, 0xbf, + 0xd0, 0x0, 0x8, 0xff, 0x20, 0x0, 0x0, 0x0, + 0xc, 0xc7, 0x0, 0x0, 0x5f, 0xf2, 0x7f, 0xf2, + 0x0, 0x2, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x4f, + 0xf9, 0x0, 0x0, 0xaf, 0xe0, 0x2f, 0xf8, 0x0, + 0x0, 0xaf, 0xf7, 0x0, 0x0, 0x3, 0xef, 0xf2, + 0x0, 0x1, 0xff, 0x90, 0xb, 0xff, 0x10, 0x0, + 0x1e, 0xff, 0xc6, 0x45, 0xaf, 0xff, 0x60, 0x0, + 0x9, 0xff, 0x20, 0x3, 0xff, 0xb0, 0x0, 0x2, + 0xdf, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x4f, + 0xfa, 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x0, 0x6, + 0xbe, 0xff, 0xc8, 0x10, 0x0, 0x2, 0xff, 0xe1, + 0x0, 0x0, 0xc, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, 0x40, 0x0, + 0x0, 0x1, 0xdf, 0xfb, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x1c, 0xff, 0xf9, 0x20, 0x0, 0x0, 0x0, + 0x5, 0xdf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xfd, 0x98, 0x67, 0x8b, 0xff, + 0xff, 0xc2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x6a, 0xdf, 0xff, 0xec, 0x83, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+00AA "ª" */ + 0x0, 0x2, 0x9e, 0xfe, 0xa2, 0x8, 0xff, 0x40, + 0x4, 0xff, 0xff, 0xff, 0xf5, 0xcf, 0xf0, 0x2, + 0xff, 0xf9, 0x33, 0xaf, 0xff, 0xfb, 0x0, 0xaf, + 0xf9, 0x0, 0x0, 0xaf, 0xff, 0x80, 0xf, 0xff, + 0x10, 0x0, 0x2, 0xff, 0xf4, 0x3, 0xff, 0xc0, + 0x0, 0x0, 0xd, 0xff, 0x10, 0x5f, 0xfa, 0x0, + 0x0, 0x0, 0xbf, 0xe0, 0x6, 0xff, 0x90, 0x0, + 0x0, 0xb, 0xfc, 0x0, 0x5f, 0xfa, 0x0, 0x0, + 0x0, 0xcf, 0xe0, 0x3, 0xff, 0xc0, 0x0, 0x0, + 0xe, 0xff, 0x20, 0xf, 0xff, 0x10, 0x0, 0x4, + 0xff, 0xf5, 0x0, 0x9f, 0xf8, 0x0, 0x0, 0xcf, + 0xff, 0xa0, 0x1, 0xff, 0xf8, 0x34, 0xbf, 0xff, + 0xff, 0x0, 0x4, 0xff, 0xff, 0xff, 0xf5, 0x9f, + 0xf4, 0x0, 0x2, 0xae, 0xfe, 0xa3, 0x0, 0x0, + 0x0, + + /* U+00AB "«" */ + 0x0, 0x0, 0x0, 0x2a, 0xa6, 0x0, 0x0, 0x7a, + 0xa2, 0x0, 0x0, 0x0, 0xdf, 0xf2, 0x0, 0x4, + 0xff, 0xc0, 0x0, 0x0, 0x9, 0xff, 0x90, 0x0, + 0x1e, 0xff, 0x30, 0x0, 0x0, 0x4f, 0xfe, 0x10, + 0x0, 0xbf, 0xf9, 0x0, 0x0, 0x1, 0xef, 0xf6, + 0x0, 0x6, 0xff, 0xf1, 0x0, 0x0, 0xb, 0xff, + 0xd0, 0x0, 0x2f, 0xff, 0x70, 0x0, 0x0, 0x6f, + 0xff, 0x40, 0x0, 0xcf, 0xfd, 0x0, 0x0, 0x2, + 0xff, 0xfb, 0x0, 0x7, 0xff, 0xf4, 0x0, 0x0, + 0xc, 0xff, 0xf2, 0x0, 0x3f, 0xff, 0xa0, 0x0, + 0x0, 0x1f, 0xff, 0xe0, 0x0, 0x6f, 0xff, 0x70, + 0x0, 0x0, 0x5, 0xff, 0xf7, 0x0, 0xb, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x10, 0x1, + 0xef, 0xfa, 0x0, 0x0, 0x0, 0x1e, 0xff, 0x90, + 0x0, 0x5f, 0xff, 0x30, 0x0, 0x0, 0x4, 0xff, + 0xf3, 0x0, 0xa, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x8f, 0xfc, 0x0, 0x1, 0xef, 0xf6, 0x0, 0x0, + 0x0, 0xd, 0xff, 0x50, 0x0, 0x4f, 0xfe, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xe0, 0x0, 0x9, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x6f, 0xf7, 0x0, 0x0, + 0xdf, 0xf2, + + /* U+00AC "¬" */ + 0x34, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, + 0x44, 0x40, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf2, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x88, 0x81, + + /* U+00AD "­" */ + 0x58, 0x88, 0x88, 0x88, 0x88, 0x80, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xf1, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xf1, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xf1, + + /* U+00AE "®" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x59, 0xce, 0xff, + 0xec, 0x83, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xfe, 0xa8, 0x77, 0x9c, 0xff, + 0xff, 0xd2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1c, + 0xff, 0xf9, 0x20, 0x0, 0x0, 0x0, 0x16, 0xdf, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xfc, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0xc, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, + 0x40, 0x0, 0x0, 0x8f, 0xf9, 0x0, 0x12, 0x22, + 0x21, 0x11, 0x0, 0x0, 0x0, 0x2, 0xef, 0xe1, + 0x0, 0x2, 0xff, 0xb0, 0x0, 0xbf, 0xff, 0xff, + 0xff, 0xfb, 0x40, 0x0, 0x0, 0x4f, 0xfa, 0x0, + 0xa, 0xff, 0x20, 0x0, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0xa, 0xff, 0x20, 0x1f, + 0xf8, 0x0, 0x0, 0xbf, 0xd0, 0x0, 0x2, 0x6f, + 0xff, 0x20, 0x0, 0x2, 0xff, 0x90, 0x6f, 0xf2, + 0x0, 0x0, 0xbf, 0xd0, 0x0, 0x0, 0x6, 0xff, + 0x60, 0x0, 0x0, 0xbf, 0xe0, 0xaf, 0xd0, 0x0, + 0x0, 0xbf, 0xd0, 0x0, 0x0, 0x4, 0xff, 0x70, + 0x0, 0x0, 0x5f, 0xf2, 0xdf, 0xa0, 0x0, 0x0, + 0xbf, 0xd0, 0x0, 0x0, 0x9, 0xff, 0x40, 0x0, + 0x0, 0x2f, 0xf5, 0xef, 0x80, 0x0, 0x0, 0xbf, + 0xd2, 0x22, 0x35, 0xaf, 0xfc, 0x0, 0x0, 0x0, + 0xf, 0xf6, 0xff, 0x70, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, 0xf, + 0xf7, 0xff, 0x80, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xff, 0xa5, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xf6, + 0xdf, 0x90, 0x0, 0x0, 0xbf, 0xd0, 0x2, 0xaf, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xf5, 0xbf, + 0xd0, 0x0, 0x0, 0xbf, 0xd0, 0x0, 0xa, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x5f, 0xf2, 0x7f, 0xf2, + 0x0, 0x0, 0xbf, 0xd0, 0x0, 0x0, 0xef, 0xe1, + 0x0, 0x0, 0x0, 0xaf, 0xe0, 0x2f, 0xf8, 0x0, + 0x0, 0xbf, 0xd0, 0x0, 0x0, 0x4f, 0xfa, 0x0, + 0x0, 0x1, 0xff, 0x90, 0xb, 0xff, 0x10, 0x0, + 0xbf, 0xd0, 0x0, 0x0, 0xb, 0xff, 0x40, 0x0, + 0x9, 0xff, 0x20, 0x3, 0xff, 0xb0, 0x0, 0xbf, + 0xd0, 0x0, 0x0, 0x2, 0xff, 0xe0, 0x0, 0x4f, + 0xfa, 0x0, 0x0, 0x9f, 0xf9, 0x0, 0x68, 0x70, + 0x0, 0x0, 0x0, 0x58, 0x83, 0x2, 0xff, 0xe1, + 0x0, 0x0, 0xc, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, 0x40, 0x0, + 0x0, 0x1, 0xdf, 0xfb, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x1c, 0xff, 0xf9, 0x20, 0x0, 0x0, 0x0, + 0x5, 0xdf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xfd, 0x98, 0x67, 0x8b, 0xff, + 0xff, 0xc2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x6a, 0xdf, 0xff, 0xec, 0x83, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+00B0 "°" */ + 0x0, 0x5, 0xcf, 0xfc, 0x50, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xfa, 0x0, 0x8, 0xff, 0x72, 0x28, + 0xff, 0x80, 0x1f, 0xf6, 0x0, 0x0, 0x6f, 0xf1, + 0x5f, 0xe0, 0x0, 0x0, 0xe, 0xf5, 0x6f, 0xb0, + 0x0, 0x0, 0xc, 0xf6, 0x5f, 0xe0, 0x0, 0x0, + 0xe, 0xf4, 0x1f, 0xf6, 0x0, 0x0, 0x6f, 0xf1, + 0x8, 0xff, 0x72, 0x38, 0xff, 0x80, 0x0, 0xaf, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x5, 0xcf, 0xfc, + 0x50, 0x0, + + /* U+00B1 "±" */ + 0x0, 0x0, 0x0, 0x0, 0xbb, 0xb3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf2, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf2, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x23, 0x33, + 0x33, 0x33, 0xff, 0xf7, 0x33, 0x33, 0x33, 0x30, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x34, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, + 0x44, 0x40, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf2, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + + /* U+00B2 "²" */ + 0x0, 0x4, 0xae, 0xff, 0xda, 0x30, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xff, 0x70, 0x6, 0xff, 0xf8, + 0x56, 0xbf, 0xff, 0x30, 0xef, 0xf4, 0x0, 0x0, + 0xcf, 0xf7, 0x5, 0x78, 0x0, 0x0, 0x8, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x30, 0x0, 0x0, 0x2, 0xdf, + 0xfe, 0x30, 0x0, 0x0, 0x5, 0xff, 0xfd, 0x20, + 0x0, 0x0, 0x8, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xfa, 0x66, 0x66, 0x66, 0x31, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfa, 0x6f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xa0, + + /* U+00B3 "³" */ + 0x0, 0x6, 0xce, 0xff, 0xc8, 0x10, 0x0, 0xb, + 0xff, 0xff, 0xff, 0xff, 0x30, 0x7, 0xff, 0xd5, + 0x34, 0xcf, 0xfb, 0x0, 0xbf, 0xf2, 0x0, 0x3, + 0xff, 0xe0, 0x0, 0x1, 0x0, 0x0, 0x4f, 0xfc, + 0x0, 0x0, 0x0, 0x3, 0x6e, 0xff, 0x40, 0x0, + 0x0, 0x4, 0xff, 0xfc, 0x30, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xfc, 0x20, 0x0, 0x0, 0x0, 0x1, + 0x6f, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xf7, 0x14, 0x54, 0x0, 0x0, 0x8, 0xff, 0x92, + 0xff, 0xe1, 0x0, 0x0, 0xdf, 0xf7, 0xb, 0xff, + 0xd6, 0x57, 0xdf, 0xff, 0x10, 0x1d, 0xff, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x6, 0xce, 0xff, 0xd8, + 0x10, 0x0, + + /* U+00B5 "µ" */ + 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf8, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf8, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf8, 0x4f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf8, 0x4f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xf8, 0x4f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf8, 0x4f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf8, 0x4f, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf8, + 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf8, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf8, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf8, 0x4f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf8, 0x4f, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xf8, 0x4f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf8, 0x4f, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf8, 0x4f, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf8, + 0x4f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xf8, 0x4f, 0xff, 0xff, 0xd6, 0x33, 0x6d, 0xff, + 0xff, 0xf8, 0x4f, 0xff, 0xef, 0xff, 0xff, 0xff, + 0xfe, 0xcf, 0xf8, 0x4f, 0xff, 0x4c, 0xff, 0xff, + 0xff, 0xe3, 0xaf, 0xf8, 0x4f, 0xff, 0x30, 0x6c, + 0xff, 0xd8, 0x10, 0xaf, 0xf8, 0x4f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00B6 "¶" */ + 0x0, 0x0, 0x2, 0x8b, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x1a, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x1d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x80, 0xc, 0xff, 0xff, 0xff, 0xff, + 0xf5, 0x55, 0x5b, 0xff, 0xd5, 0x52, 0x5, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x9f, 0xfb, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x9, 0xff, 0xb0, 0x0, 0xe, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x9f, 0xfb, 0x0, + 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x9, 0xff, 0xb0, 0x0, 0xf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x9f, 0xfb, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x9, + 0xff, 0xb0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x9f, 0xfb, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x9, 0xff, + 0xb0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x9f, 0xfb, 0x0, 0x0, 0x2, 0xef, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x9, 0xff, 0xb0, + 0x0, 0x0, 0x2, 0xcf, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x9f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x49, + 0xcd, 0xff, 0xf0, 0x0, 0x9, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x0, 0x0, + 0x9f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf0, 0x0, 0x9, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x0, 0x0, 0x9f, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf0, 0x0, 0x9, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0x0, 0x0, 0x9f, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf0, + 0x0, 0x9, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0x0, 0x0, 0x9f, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf0, 0x0, + 0x9, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x0, 0x0, 0x9f, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf0, 0x0, 0x9, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0x0, 0x0, 0x9f, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf0, 0x0, 0x9, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0x0, 0x0, 0x9f, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf0, 0x0, 0x9, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x0, + 0x0, 0x9f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf0, 0x0, 0x9, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x0, 0x0, + 0x9f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf0, 0x0, 0x9, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x0, 0x0, 0x9f, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf0, 0x0, 0x9, 0xff, 0xb0, 0x0, + + /* U+00B7 "·" */ + 0x6f, 0xff, 0x96, 0xff, 0xf9, 0x6f, 0xff, 0x96, + 0xff, 0xf9, + + /* U+00BB "»" */ + 0x9, 0xa9, 0x0, 0x0, 0x3a, 0xa5, 0x0, 0x0, + 0x0, 0x8, 0xff, 0x80, 0x0, 0xe, 0xff, 0x20, + 0x0, 0x0, 0x0, 0xef, 0xf3, 0x0, 0x5, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x5f, 0xfe, 0x0, 0x0, + 0xcf, 0xf8, 0x0, 0x0, 0x0, 0xc, 0xff, 0xa0, + 0x0, 0x3f, 0xff, 0x30, 0x0, 0x0, 0x3, 0xff, + 0xf5, 0x0, 0x9, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x9f, 0xfe, 0x10, 0x1, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xb0, 0x0, 0x7f, 0xff, 0x50, + 0x0, 0x0, 0x6, 0xff, 0xf6, 0x0, 0xd, 0xff, + 0xf1, 0x0, 0x0, 0x3, 0xff, 0xfa, 0x0, 0xa, + 0xff, 0xf4, 0x0, 0x0, 0xc, 0xff, 0xe1, 0x0, + 0x3f, 0xff, 0x90, 0x0, 0x0, 0x6f, 0xff, 0x40, + 0x0, 0xcf, 0xfd, 0x0, 0x0, 0x0, 0xef, 0xf9, + 0x0, 0x6, 0xff, 0xf3, 0x0, 0x0, 0x8, 0xff, + 0xd0, 0x0, 0xe, 0xff, 0x80, 0x0, 0x0, 0x2f, + 0xff, 0x30, 0x0, 0x8f, 0xfc, 0x0, 0x0, 0x0, + 0xbf, 0xf8, 0x0, 0x2, 0xff, 0xf2, 0x0, 0x0, + 0x5, 0xff, 0xc0, 0x0, 0xa, 0xff, 0x60, 0x0, + 0x0, 0xd, 0xff, 0x20, 0x0, 0x4f, 0xfa, 0x0, + 0x0, 0x0, + + /* U+00BD "½" */ + 0x0, 0x0, 0x1a, 0xa3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xaa, 0x80, 0x0, 0x0, + 0x0, 0x1c, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf3, 0x0, 0x0, 0x0, + 0x3d, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf7, 0x0, 0x0, 0x1, 0x9f, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xfc, 0x0, 0x0, 0x0, 0xef, 0xfd, + 0xbf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0x20, 0x0, 0x0, 0xe, 0xe8, 0x8, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x40, 0x0, 0x8f, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf4, 0x0, 0x0, + 0x0, 0xb, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0x40, 0x0, 0x0, + 0x6, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xf4, 0x0, 0x0, 0x2, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xf3, 0x0, 0x0, 0x0, 0x34, 0x42, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf8, + 0x0, 0x0, 0x19, 0xff, 0xff, 0xff, 0x91, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xfc, 0x0, + 0x0, 0x1d, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0x20, 0x0, + 0x9, 0xff, 0xc3, 0x1, 0x6f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0x50, 0x0, 0x0, + 0xdf, 0xf1, 0x0, 0x0, 0x9f, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x1, 0x0, 0x0, 0x9, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xef, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2c, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4e, 0xff, + 0xc2, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xa5, 0x55, + 0x55, 0x53, 0x0, 0x2, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0xcf, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0x0, 0x28, 0x85, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+0384 "΄" */ + 0x0, 0x16, 0x66, 0x62, 0x0, 0x7f, 0xff, 0xc0, + 0x0, 0xef, 0xfe, 0x10, 0x7, 0xff, 0xf4, 0x0, + 0xe, 0xff, 0x70, 0x0, 0x6f, 0xfa, 0x0, 0x0, + + /* U+0386 "Ά" */ + 0x0, 0x0, 0x9f, 0xff, 0xd0, 0x3, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xfe, 0x20, 0x9, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf4, + 0x0, 0xf, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x70, 0x0, 0x6f, + 0xfc, 0xef, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xfb, 0x0, 0x0, 0xcf, 0xf8, 0x9f, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x56, + 0x60, 0x0, 0x2, 0xff, 0xf4, 0x3f, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xe0, 0xd, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0x90, 0x7, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x30, 0x1, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xfd, 0x0, 0x0, 0xaf, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf7, 0x0, 0x0, 0x4f, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf1, + 0x0, 0x0, 0xd, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xa0, 0x0, 0x0, + 0x7, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x30, 0x0, 0x0, 0x1, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x11, 0x11, + 0x11, 0x11, 0x11, 0x11, 0xbf, 0xff, 0x30, 0x0, + 0x0, 0x1, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xa0, 0x0, 0x0, 0x7, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xf1, 0x0, 0x0, 0xd, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf7, 0x0, 0x0, 0x4f, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfe, 0x0, + 0x0, 0xaf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x50, 0x1, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xb0, 0x6, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xf2, 0xd, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf9, + + /* U+0388 "Έ" */ + 0x0, 0x6f, 0xff, 0xe2, 0x2, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x0, 0xdf, 0xff, 0x40, 0x2, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x5, 0xff, 0xf7, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, + 0xc, 0xff, 0xb0, 0x0, 0x2, 0xff, 0xfc, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x20, + 0x4f, 0xfd, 0x0, 0x0, 0x2, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x46, 0x62, 0x0, 0x0, 0x2, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfb, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x52, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfc, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x51, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, + + /* U+0389 "Ή" */ + 0x0, 0x5f, 0xff, 0xf2, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf8, + 0x0, 0xdf, 0xff, 0x40, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf8, + 0x5, 0xff, 0xf8, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf8, + 0xc, 0xff, 0xb0, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf8, + 0x4f, 0xfd, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf8, + 0x46, 0x62, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xe5, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x58, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf8, + + /* U+038A "Ί" */ + 0x0, 0x5f, 0xff, 0xf2, 0xf, 0xff, 0xd0, 0xd, + 0xff, 0xf4, 0x0, 0xff, 0xfd, 0x5, 0xff, 0xf8, + 0x0, 0xf, 0xff, 0xd0, 0xcf, 0xfb, 0x0, 0x0, + 0xff, 0xfd, 0x4f, 0xfd, 0x0, 0x0, 0xf, 0xff, + 0xd4, 0x66, 0x20, 0x0, 0x0, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xfd, + + /* U+038C "Ό" */ + 0x0, 0x6f, 0xff, 0xe2, 0x0, 0x0, 0x37, 0xbd, + 0xef, 0xed, 0xb6, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x40, 0x0, 0x4c, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x30, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf7, 0x0, 0x1b, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xb0, 0x2, 0xdf, 0xff, 0xfe, 0xa6, + 0x54, 0x57, 0xbf, 0xff, 0xff, 0xb1, 0x0, 0x0, + 0x4f, 0xfd, 0x0, 0x1e, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x1, 0x9f, 0xff, 0xfc, 0x0, 0x0, + 0x46, 0x62, 0x0, 0xcf, 0xff, 0xd2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x20, + 0x0, 0x0, 0x9f, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x70, + 0x0, 0x0, 0xdf, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xb0, + 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xe0, + 0x0, 0x2, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf0, + 0x0, 0x3, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf1, + 0x0, 0x4, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf1, + 0x0, 0x3, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf0, + 0x0, 0x1, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xe0, + 0x0, 0x0, 0xef, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xb0, + 0x0, 0x0, 0xaf, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x70, + 0x0, 0x0, 0x5f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x30, + 0x0, 0x0, 0xe, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xd1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xef, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x2e, 0xff, 0xfe, 0x60, 0x0, + 0x0, 0x0, 0x1, 0x8f, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0xfe, 0x95, + 0x43, 0x46, 0xaf, 0xff, 0xff, 0xc1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1b, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5d, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x38, 0xbe, + 0xff, 0xed, 0xb6, 0x20, 0x0, 0x0, 0x0, 0x0, + + /* U+038E "Ύ" */ + 0x0, 0x6f, 0xff, 0xe2, 0x3, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xf5, 0x0, 0xdf, 0xff, 0x40, 0x0, 0x8f, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x90, 0x5, 0xff, 0xf7, 0x0, + 0x0, 0xd, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xfd, 0x0, 0xc, 0xff, + 0xb0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf3, 0x0, + 0x4f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x70, 0x0, 0x46, 0x62, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfa, 0x0, 0x0, 0x6, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0x50, 0x0, 0x1f, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xe1, 0x0, + 0xbf, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf9, 0x5, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0x3e, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+038F "Ώ" */ + 0x0, 0x6f, 0xff, 0xe2, 0x0, 0x0, 0x38, 0xbe, + 0xff, 0xed, 0xa6, 0x10, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xf4, 0x0, 0x5, 0xdf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x91, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf7, 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe3, 0x0, 0x0, 0x0, 0xcf, + 0xfb, 0x0, 0x1c, 0xff, 0xff, 0xfa, 0x64, 0x45, + 0x8d, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x4f, 0xfd, + 0x0, 0xb, 0xff, 0xff, 0x91, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xf2, 0x0, 0x4, 0x66, 0x20, + 0x7, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xef, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xfd, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf3, 0x0, 0x0, 0x2, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0x80, 0x0, 0x0, 0x5f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xfb, 0x0, 0x0, 0x8, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xd0, 0x0, 0x0, 0x9f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xfd, 0x0, 0x0, 0x9, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xe0, 0x0, 0x0, 0x8f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfd, + 0x0, 0x0, 0x5, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xa0, + 0x0, 0x0, 0x2f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0xef, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x30, 0x0, + 0x0, 0x8, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xdf, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xdf, 0xfc, 0x20, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x45, 0x55, + 0x56, 0xff, 0xff, 0x80, 0x0, 0x5, 0xdf, 0xff, + 0x95, 0x55, 0x55, 0x10, 0x0, 0xe, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x40, 0x0, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0xe, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x30, 0x0, 0xe, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x40, 0x0, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xf3, + + /* U+0390 "ΐ" */ + 0x0, 0x0, 0x0, 0xb, 0xff, 0xc0, 0x0, 0x7, + 0xbb, 0x80, 0x3, 0xff, 0xe1, 0x9b, 0xb6, 0xaf, + 0xfb, 0x0, 0xbf, 0xf3, 0xd, 0xff, 0x8a, 0xff, + 0xb0, 0x3f, 0xf7, 0x0, 0xdf, 0xf8, 0xaf, 0xfb, + 0xb, 0xfa, 0x0, 0xd, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf3, 0x0, + 0x0, 0x0, + + /* U+0391 "Α" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xfc, 0xdf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf8, 0x8f, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xf4, 0x2f, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xe0, 0xc, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0x90, 0x6, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x30, 0x1, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xfc, 0x0, 0x0, 0xaf, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf6, 0x0, 0x0, 0x3f, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, + 0x0, 0x0, 0xd, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xa0, 0x0, 0x0, + 0x7, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x30, 0x0, 0x0, 0x1, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x11, 0x11, + 0x11, 0x11, 0x11, 0x11, 0xbf, 0xff, 0x30, 0x0, + 0x0, 0x1, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xa0, 0x0, 0x0, 0x7, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xf1, 0x0, 0x0, 0xd, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf7, 0x0, 0x0, 0x4f, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfe, 0x0, + 0x0, 0xaf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x50, 0x1, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xb0, 0x6, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xf2, 0xd, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf9, + + /* U+0392 "Β" */ + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xb8, + 0x30, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc3, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0xff, 0xfd, 0x55, 0x55, 0x55, + 0x66, 0x8b, 0xff, 0xff, 0xf2, 0x0, 0xf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xbf, 0xff, + 0xa0, 0x0, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0x0, 0xf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf1, + 0x0, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0x20, 0xf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf0, 0x0, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xfb, 0x0, 0xf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xbf, 0xff, 0x30, 0x0, 0xff, + 0xfd, 0x55, 0x55, 0x55, 0x56, 0x8b, 0xff, 0xff, + 0x50, 0x0, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x30, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd7, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x30, 0x0, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x24, 0x8e, 0xff, 0xfe, 0x20, + 0xf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xfb, 0x0, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf3, 0xf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0x70, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf8, 0xf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x80, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf6, 0xf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0x20, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xdf, 0xff, 0xb0, 0xf, 0xff, 0xd5, 0x55, + 0x55, 0x55, 0x56, 0x9d, 0xff, 0xff, 0xf2, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf4, 0x0, 0xf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc2, 0x0, 0x0, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xed, 0xa7, 0x20, + 0x0, 0x0, + + /* U+0393 "Γ" */ + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x1c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf1, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x1c, 0xff, 0xf5, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x50, 0xcf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0394 "Δ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xfc, 0xef, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf8, 0x9f, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf4, 0x4f, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xe0, 0xe, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xa0, 0x8, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x40, 0x2, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xfe, 0x0, 0x0, 0xcf, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf8, 0x0, 0x0, 0x6f, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf2, + 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xc0, 0x0, 0x0, + 0x9, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x60, 0x0, 0x0, 0x3, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x10, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x30, 0x0, + 0x0, 0x1, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x90, 0x0, 0x0, 0x7, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xf1, 0x0, 0x0, 0xe, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf7, 0x0, 0x0, 0x4f, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfd, 0x0, + 0x0, 0xaf, 0xff, 0x95, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0xff, 0xff, 0x40, 0x1, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb0, 0x7, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf2, 0xd, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + + /* U+0395 "Ε" */ + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe0, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe0, 0xdf, 0xff, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x40, 0xdf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x54, 0x0, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x0, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x0, 0xdf, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x52, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf8, + + /* U+0396 "Ζ" */ + 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe0, 0x0, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe0, 0x0, 0x35, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x56, 0xef, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1d, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfe, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf9, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x51, 0x4f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf5, 0x4f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + + /* U+0397 "Η" */ + 0xcf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xac, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfa, 0xcf, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xac, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xfa, 0xcf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xac, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xfa, 0xcf, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xac, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xfa, 0xcf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xac, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xfa, 0xcf, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xac, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xac, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0xcf, 0xff, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x6f, 0xff, 0xac, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfa, + 0xcf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xac, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfa, 0xcf, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xac, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xfa, 0xcf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xac, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xfa, 0xcf, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xac, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xfa, 0xcf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xac, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xfa, 0xcf, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xac, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xfa, + + /* U+0398 "Θ" */ + 0x0, 0x0, 0x0, 0x0, 0x2, 0x6b, 0xde, 0xfe, + 0xdb, 0x73, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3b, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xcf, 0xff, + 0xff, 0xb7, 0x54, 0x56, 0xae, 0xff, 0xff, 0xd2, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf8, 0x10, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xe3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xef, 0xff, 0xb0, 0x0, 0x0, + 0x4f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xef, 0xff, 0x60, 0x0, 0xc, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xfd, 0x0, 0x3, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf5, 0x0, 0x7f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x90, 0xb, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfe, 0x0, + 0xef, 0xff, 0x0, 0x0, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x51, 0x0, 0xd, 0xff, 0xf0, 0xf, 0xff, + 0xe0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x30, 0x0, 0xcf, 0xff, 0x21, 0xff, 0xfd, 0x0, + 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0xa, 0xff, 0xf3, 0x1f, 0xff, 0xc0, 0x0, 0x1f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, 0xaf, + 0xff, 0x30, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf2, + 0xf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x10, 0xcf, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xe0, 0x7, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xfa, 0x0, 0x2f, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x50, 0x0, 0xcf, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xe0, + 0x0, 0x4, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xf6, 0x0, 0x0, + 0xa, 0xff, 0xfe, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2d, 0xff, 0xfb, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x7e, + 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x1d, 0xff, + 0xff, 0xea, 0x64, 0x34, 0x6a, 0xef, 0xff, 0xfd, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x27, 0xbd, 0xff, 0xed, + 0xb7, 0x20, 0x0, 0x0, 0x0, 0x0, + + /* U+0399 "Ι" */ + 0x5f, 0xff, 0x75, 0xff, 0xf7, 0x5f, 0xff, 0x75, + 0xff, 0xf7, 0x5f, 0xff, 0x75, 0xff, 0xf7, 0x5f, + 0xff, 0x75, 0xff, 0xf7, 0x5f, 0xff, 0x75, 0xff, + 0xf7, 0x5f, 0xff, 0x75, 0xff, 0xf7, 0x5f, 0xff, + 0x75, 0xff, 0xf7, 0x5f, 0xff, 0x75, 0xff, 0xf7, + 0x5f, 0xff, 0x75, 0xff, 0xf7, 0x5f, 0xff, 0x75, + 0xff, 0xf7, 0x5f, 0xff, 0x75, 0xff, 0xf7, 0x5f, + 0xff, 0x75, 0xff, 0xf7, 0x5f, 0xff, 0x75, 0xff, + 0xf7, 0x5f, 0xff, 0x75, 0xff, 0xf7, + + /* U+039A "Κ" */ + 0xf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf8, 0x0, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf8, + 0x0, 0xf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xf7, 0x0, 0x0, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf6, + 0x0, 0x0, 0xf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf5, 0x0, 0x0, 0x0, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xe3, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xb0, 0x0, + 0x0, 0xbf, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xfb, 0x0, 0x0, 0xbf, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xb0, + 0x0, 0xbf, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xfb, 0x0, 0xcf, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xb0, 0xcf, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xfc, 0xcf, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xff, 0xb2, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xa0, + 0x6, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0x90, 0x0, 0xa, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x90, + 0x0, 0x0, 0xe, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xe1, 0x0, 0x0, 0x0, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xb0, 0x0, 0x0, 0xf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0x70, 0x0, 0x0, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0x30, 0x0, 0xf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xfe, 0x10, + 0x0, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xfb, 0x0, 0xf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xf7, 0x0, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf4, + + /* U+039B "Λ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xbf, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xd3, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xf8, 0xe, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x30, + 0x9f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xd0, 0x3, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf7, 0x0, 0xd, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x10, + 0x0, 0x7f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xb0, 0x0, 0x2, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf5, 0x0, 0x0, 0xc, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0x90, 0x0, 0x0, 0x0, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x10, 0x0, 0x0, 0xc, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xf6, 0x0, 0x0, 0x2, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xd0, + 0x0, 0x0, 0x9f, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x30, 0x0, 0xf, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf9, 0x0, 0x6, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf0, 0x0, 0xcf, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x60, 0x2f, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xfc, 0x9, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf3, + + /* U+039C "Μ" */ + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xf5, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xf5, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xf5, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf5, + 0xff, 0xfe, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf5, 0xff, 0xfa, + 0xef, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xfa, 0xff, 0xf5, 0xff, 0xfa, 0x8f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf5, + 0xff, 0xf5, 0xff, 0xfa, 0x2f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xa5, 0xff, 0xf5, + 0xff, 0xfa, 0xd, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0x45, 0xff, 0xf5, 0xff, 0xfa, + 0x7, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xfe, 0x5, 0xff, 0xf5, 0xff, 0xfa, 0x2, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, 0x5, + 0xff, 0xf5, 0xff, 0xfa, 0x0, 0xcf, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf3, 0x5, 0xff, 0xf5, + 0xff, 0xfa, 0x0, 0x7f, 0xff, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xd0, 0x5, 0xff, 0xf5, 0xff, 0xfa, + 0x0, 0x1f, 0xff, 0x50, 0x0, 0x0, 0x8, 0xff, + 0x80, 0x5, 0xff, 0xf5, 0xff, 0xfa, 0x0, 0xc, + 0xff, 0xa0, 0x0, 0x0, 0xd, 0xff, 0x20, 0x5, + 0xff, 0xf5, 0xff, 0xfa, 0x0, 0x6, 0xff, 0xf0, + 0x0, 0x0, 0x3f, 0xfc, 0x0, 0x5, 0xff, 0xf5, + 0xff, 0xfa, 0x0, 0x1, 0xff, 0xf5, 0x0, 0x0, + 0x9f, 0xf7, 0x0, 0x5, 0xff, 0xf5, 0xff, 0xfa, + 0x0, 0x0, 0xbf, 0xfb, 0x0, 0x0, 0xef, 0xf1, + 0x0, 0x5, 0xff, 0xf5, 0xff, 0xfa, 0x0, 0x0, + 0x5f, 0xff, 0x0, 0x4, 0xff, 0xb0, 0x0, 0x5, + 0xff, 0xf5, 0xff, 0xfa, 0x0, 0x0, 0xf, 0xff, + 0x50, 0xa, 0xff, 0x60, 0x0, 0x5, 0xff, 0xf5, + 0xff, 0xfa, 0x0, 0x0, 0xa, 0xff, 0xb0, 0xf, + 0xff, 0x0, 0x0, 0x5, 0xff, 0xf5, 0xff, 0xfa, + 0x0, 0x0, 0x5, 0xff, 0xf1, 0x5f, 0xfa, 0x0, + 0x0, 0x5, 0xff, 0xf5, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0xff, 0xf5, 0xaf, 0xf4, 0x0, 0x0, 0x5, + 0xff, 0xf5, 0xff, 0xfa, 0x0, 0x0, 0x0, 0xaf, + 0xfb, 0xff, 0xe0, 0x0, 0x0, 0x5, 0xff, 0xf5, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x5, 0xff, 0xf5, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x5, 0xff, 0xf5, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf5, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf5, + + /* U+039D "Ν" */ + 0xdf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xbd, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfb, 0xdf, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xbd, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xfb, 0xdf, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xbd, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xfb, 0xdf, 0xfd, 0xdf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xbd, 0xff, 0xc3, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xfb, 0xdf, 0xfc, 0x7, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xbd, + 0xff, 0xc0, 0xc, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xfb, 0xdf, 0xfc, 0x0, 0x2f, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0xe, 0xff, 0xbd, 0xff, + 0xc0, 0x0, 0x7f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0xef, 0xfb, 0xdf, 0xfc, 0x0, 0x0, 0xcf, 0xff, + 0x90, 0x0, 0x0, 0xe, 0xff, 0xbd, 0xff, 0xc0, + 0x0, 0x2, 0xff, 0xff, 0x40, 0x0, 0x0, 0xef, + 0xfb, 0xdf, 0xfc, 0x0, 0x0, 0x6, 0xff, 0xfe, + 0x10, 0x0, 0xe, 0xff, 0xbd, 0xff, 0xc0, 0x0, + 0x0, 0xb, 0xff, 0xfa, 0x0, 0x0, 0xef, 0xfb, + 0xdf, 0xfc, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xf5, + 0x0, 0xe, 0xff, 0xbd, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xe1, 0x0, 0xef, 0xfb, 0xdf, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, + 0xe, 0xff, 0xbd, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0x60, 0xef, 0xfb, 0xdf, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x2e, + 0xff, 0xbd, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xfc, 0xef, 0xfb, 0xdf, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, + 0xbd, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xfb, 0xdf, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xbd, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xfb, 0xdf, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xbd, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xfb, + + /* U+039E "Ξ" */ + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf5, 0x5f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf5, 0x15, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x51, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x25, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x52, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x45, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x54, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, + + /* U+039F "Ο" */ + 0x0, 0x0, 0x0, 0x0, 0x2, 0x6b, 0xde, 0xfe, + 0xdb, 0x73, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3b, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xcf, 0xff, + 0xff, 0xb7, 0x54, 0x56, 0xae, 0xff, 0xff, 0xd2, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf8, 0x10, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xe3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xef, 0xff, 0xb0, 0x0, 0x0, + 0x4f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xef, 0xff, 0x60, 0x0, 0xc, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xfd, 0x0, 0x3, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf5, 0x0, 0x7f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x90, 0xb, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfe, 0x0, + 0xef, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf0, 0xf, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x21, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf3, 0x1f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0x30, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf2, + 0xf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x10, 0xcf, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xe0, 0x7, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xfa, 0x0, 0x2f, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x50, 0x0, 0xcf, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xe0, + 0x0, 0x4, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xf6, 0x0, 0x0, + 0xa, 0xff, 0xfe, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2d, 0xff, 0xfb, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x7e, + 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x1d, 0xff, + 0xff, 0xea, 0x64, 0x34, 0x6a, 0xef, 0xff, 0xfd, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x27, 0xbd, 0xff, 0xed, + 0xb7, 0x20, 0x0, 0x0, 0x0, 0x0, + + /* U+03A0 "Π" */ + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xac, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xac, 0xff, 0xf5, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x56, 0xff, 0xfa, 0xcf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xac, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xfa, 0xcf, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xac, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xfa, 0xcf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xac, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xfa, 0xcf, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xac, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xfa, 0xcf, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xac, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xfa, 0xcf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xac, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfa, + 0xcf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xac, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfa, 0xcf, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xac, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xfa, 0xcf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xac, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xfa, 0xcf, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xac, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xfa, 0xcf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xac, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xfa, 0xcf, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xac, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xfa, + + /* U+03A1 "Ρ" */ + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xca, + 0x71, 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x0, 0xef, 0xfe, 0x55, 0x55, 0x55, 0x55, 0x56, + 0x9e, 0xff, 0xff, 0xa0, 0xef, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf3, 0xef, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xf9, 0xef, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xfc, 0xef, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfe, + 0xef, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xfe, 0xef, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xfc, 0xef, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf8, 0xef, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xf3, 0xef, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x2, 0x6c, 0xff, 0xff, 0xa0, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x10, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb1, 0x0, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0xa4, 0x0, 0x0, + 0xef, 0xfe, 0x55, 0x55, 0x55, 0x55, 0x43, 0x10, + 0x0, 0x0, 0x0, 0xef, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+03A3 "Σ" */ + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x50, 0x1f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x1f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x50, 0x1f, 0xff, 0xf8, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x10, 0x6, 0xff, 0xfe, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xfe, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xfd, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2e, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xf8, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x50, 0x1f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x1f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf2, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf2, + + /* U+03A4 "Τ" */ + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x2f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x5, 0x55, 0x55, 0x55, + 0x55, 0xcf, 0xff, 0x65, 0x55, 0x55, 0x55, 0x53, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + + /* U+03A5 "Υ" */ + 0x8f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xfe, 0x10, 0xdf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0x50, 0x3, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x90, + 0x0, 0x7, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x0, 0xc, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xb0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0x60, 0x0, 0x0, 0xcf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x10, + 0x0, 0x6f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xfb, 0x0, 0x1f, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xf4, 0xb, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xd5, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+03A6 "Φ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x33, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xd1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x8c, + 0xef, 0xff, 0xff, 0xff, 0xfe, 0xb7, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xe8, 0x41, 0xf, 0xff, + 0xd0, 0x14, 0x9f, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x4f, 0xff, 0xf9, 0x0, 0x0, 0xf, 0xff, 0xd0, + 0x0, 0x1, 0xaf, 0xff, 0xf4, 0x0, 0x0, 0xef, + 0xff, 0x70, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x9, 0xff, 0xfd, 0x0, 0x6, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x60, 0xc, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xb0, 0x1f, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf0, 0x3f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf2, 0x5f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf3, + 0x4f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf2, 0x3f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xf1, 0x1f, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf0, 0xc, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xa0, 0x6, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x50, 0x0, 0xdf, 0xff, 0xa0, 0x0, + 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x9, 0xff, + 0xfc, 0x0, 0x0, 0x4f, 0xff, 0xfc, 0x30, 0x0, + 0xf, 0xff, 0xd0, 0x0, 0x2, 0xbf, 0xff, 0xf3, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xfb, 0x73, 0x2f, + 0xff, 0xe2, 0x36, 0xbf, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x4e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd3, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x59, 0xce, 0xff, 0xff, 0xff, 0xec, + 0x95, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+03A7 "Χ" */ + 0x2, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xf4, 0x0, 0x6, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf7, 0x0, 0x0, 0xb, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xa0, 0x0, + 0x0, 0x8f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0x60, 0x0, 0x4f, 0xff, + 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0x20, 0x1e, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfc, + 0xb, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xfc, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf9, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf6, 0xc, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xfb, 0x0, 0x2f, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xfe, 0x10, 0x0, + 0x6f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x40, 0x0, 0x0, 0xaf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x80, 0x0, 0x0, 0x1, 0xef, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x3f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfd, + 0x0, 0x0, 0x1d, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf9, 0x0, 0xa, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf5, 0x7, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xe1, + + /* U+03A8 "Ψ" */ + 0x8f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0x90, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf8, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x8f, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x90, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf8, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0x8f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x90, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xf8, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x8f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x90, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xf8, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xfe, 0x7f, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xe6, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xfd, 0x5f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xb1, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xf8, 0xd, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x90, 0x0, + 0x0, 0x0, 0xef, 0xff, 0x40, 0x7f, 0xff, 0xe1, + 0x0, 0x0, 0x3, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xd0, 0x0, 0xef, 0xff, 0xe4, 0x0, + 0x0, 0x3f, 0xff, 0x90, 0x0, 0x1, 0xaf, 0xff, + 0xf5, 0x0, 0x3, 0xff, 0xff, 0xfd, 0x73, 0x3, + 0xff, 0xf9, 0x2, 0x59, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x2, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x28, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd9, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x25, 0xff, 0xfa, 0x21, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A9 "Ω" */ + 0x0, 0x0, 0x0, 0x0, 0x4, 0x9c, 0xef, 0xfe, + 0xca, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xef, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, 0xe9, + 0x54, 0x45, 0x9e, 0xff, 0xff, 0xe2, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x4f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xf3, 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xfa, 0x0, + 0x1, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x0, 0x6, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x50, 0x9, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0x70, 0xb, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xa0, + 0xc, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xa0, 0xc, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xb0, 0xb, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xa0, 0x9, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x70, + 0x6, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x40, 0x1, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0x0, 0x0, 0xbf, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xf9, 0x0, 0x0, 0x3f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf2, 0x0, + 0x0, 0xa, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0x90, 0x0, 0x0, 0x1, + 0xef, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xef, 0xfa, 0x10, + 0x0, 0x0, 0x1, 0xaf, 0xfe, 0x20, 0x0, 0x0, + 0x5, 0x55, 0x55, 0x8f, 0xff, 0xe6, 0x0, 0x0, + 0x7e, 0xff, 0xf7, 0x55, 0x55, 0x50, 0x1f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf0, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x0, 0x1, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf0, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, + + /* U+03AA "Ϊ" */ + 0xf, 0xff, 0xa0, 0x0, 0xbf, 0xff, 0xf, 0xff, + 0xa0, 0x0, 0xbf, 0xff, 0xf, 0xff, 0xa0, 0x0, + 0xbf, 0xff, 0xf, 0xff, 0xa0, 0x0, 0xbf, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x60, 0x0, + + /* U+03AB "Ϋ" */ + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf7, 0x0, 0xf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0x70, 0x0, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf7, 0x0, 0xf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x70, 0x0, + 0xef, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xfe, 0x10, 0xdf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0x50, 0x3, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x90, 0x0, 0x7, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x0, + 0xc, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xb0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0x60, 0x0, 0x0, 0xcf, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x10, 0x0, 0x6f, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xfb, 0x0, 0x1f, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xf4, 0xb, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xd5, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+03AC "ά" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x26, 0x66, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x39, 0xdf, 0xfd, 0xa4, 0x0, 0x1, 0xff, + 0xf7, 0x0, 0x1, 0xbf, 0xff, 0xff, 0xff, 0xfc, + 0x10, 0x6f, 0xff, 0x20, 0x1, 0xdf, 0xff, 0xff, + 0xef, 0xff, 0xfd, 0x1a, 0xff, 0xe0, 0x0, 0xbf, + 0xff, 0xe6, 0x0, 0x3, 0xbf, 0xfb, 0xef, 0xfa, + 0x0, 0x5f, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0x60, 0xc, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xf2, 0x1, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfe, 0x0, + 0x5f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xb0, 0x7, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xf8, 0x0, 0x8f, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0x40, 0x9, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xf2, 0x0, 0x8f, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0x40, 0x7, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf7, 0x0, 0x4f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xa0, 0x1, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xfd, 0x0, 0xb, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xf1, 0x0, 0x4f, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0x50, 0x0, 0xaf, 0xff, 0xe5, 0x0, 0x4, 0xdf, + 0xf8, 0xff, 0xf8, 0x0, 0x1, 0xcf, 0xff, 0xff, + 0xef, 0xff, 0xfd, 0xb, 0xff, 0xd0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xff, 0xfd, 0x20, 0x6f, 0xff, + 0x10, 0x0, 0x0, 0x39, 0xdf, 0xfe, 0xb5, 0x0, + 0x1, 0xff, 0xf7, + + /* U+03AD "έ" */ + 0x0, 0x0, 0x0, 0x0, 0x46, 0x66, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x29, 0xde, 0xfe, 0xc7, 0x10, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0xef, 0xfe, 0x51, 0x2, 0x8f, 0xff, 0x50, + 0x4, 0xff, 0xf4, 0x0, 0x0, 0x1, 0x92, 0x0, + 0x7, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xa3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1c, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x2, 0xef, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xfe, 0x60, 0x0, 0x0, + 0x5, 0xff, 0xfe, 0x61, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x7f, 0x50, + 0x8, 0xff, 0xfd, 0x40, 0x0, 0x4c, 0xff, 0xf8, + 0x0, 0xdf, 0xff, 0xff, 0xef, 0xff, 0xff, 0xe2, + 0x0, 0x2c, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x10, + 0x0, 0x0, 0x5a, 0xef, 0xfe, 0xb7, 0x20, 0x0, + + /* U+03AE "ή" */ + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0x65, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xfe, 0x0, 0x17, 0xce, 0xfe, 0xc7, 0x10, + 0x0, 0x4f, 0xfe, 0x5, 0xef, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0x4f, 0xfe, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x40, 0x4f, 0xff, 0xff, 0xe6, 0x20, + 0x14, 0xcf, 0xff, 0xd0, 0x4f, 0xff, 0xfc, 0x10, + 0x0, 0x0, 0xd, 0xff, 0xf3, 0x4f, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf6, 0x4f, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf8, 0x4f, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf8, + 0x4f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf9, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf9, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf9, 0x4f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf9, 0x4f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xf9, 0x4f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf9, 0x4f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf9, 0x4f, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf9, + 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf9, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf9, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf9, 0x4f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf9, 0x4f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xf9, + + /* U+03AF "ί" */ + 0x0, 0x8f, 0xff, 0xd0, 0x1, 0xff, 0xff, 0x20, + 0x8, 0xff, 0xf5, 0x0, 0xe, 0xff, 0x80, 0x0, + 0x7f, 0xfb, 0x0, 0x0, 0x56, 0x61, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x30, 0x0, 0x5f, 0xff, 0x30, 0x0, + 0x5f, 0xff, 0x30, 0x0, 0x5f, 0xff, 0x30, 0x0, + 0x5f, 0xff, 0x30, 0x0, 0x5f, 0xff, 0x30, 0x0, + 0x5f, 0xff, 0x30, 0x0, 0x5f, 0xff, 0x30, 0x0, + 0x5f, 0xff, 0x30, 0x0, 0x5f, 0xff, 0x30, 0x0, + 0x5f, 0xff, 0x30, 0x0, 0x5f, 0xff, 0x30, 0x0, + 0x5f, 0xff, 0x30, 0x0, 0x5f, 0xff, 0x30, 0x0, + 0x5f, 0xff, 0x30, 0x0, 0x5f, 0xff, 0x30, 0x0, + 0x5f, 0xff, 0x30, 0x0, 0x5f, 0xff, 0x30, 0x0, + 0x5f, 0xff, 0x30, 0x0, 0x5f, 0xff, 0x30, 0x0, + 0x5f, 0xff, 0x30, 0x0, + + /* U+03B0 "ΰ" */ + 0x0, 0x0, 0x0, 0x0, 0x7, 0x88, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfe, 0x10, + 0x0, 0x0, 0x2, 0xff, 0xf4, 0x0, 0xef, 0xf3, + 0x5f, 0xff, 0x10, 0x2, 0xff, 0xf4, 0x6, 0xff, + 0x70, 0x5f, 0xff, 0x10, 0x2, 0xff, 0xf4, 0xd, + 0xfb, 0x0, 0x5f, 0xff, 0x10, 0x1, 0xbb, 0xb2, + 0x3b, 0xa1, 0x0, 0x3b, 0xbb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf4, 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf4, 0x5f, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf4, 0x5f, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf4, 0x5f, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf4, 0x5f, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf4, 0x5f, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf4, + 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf4, 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf4, 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf4, 0x5f, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf4, 0x5f, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf4, 0x5f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf3, 0x4f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf2, 0x2f, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, + 0xf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xc0, 0xa, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0x70, 0x2, 0xff, 0xff, 0x91, 0x0, 0x2a, + 0xff, 0xfe, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xef, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x4, 0xef, 0xff, + 0xff, 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, 0x6, + 0xbe, 0xff, 0xda, 0x50, 0x0, 0x0, + + /* U+03B1 "α" */ + 0x0, 0x0, 0x3, 0x9d, 0xff, 0xda, 0x40, 0x0, + 0x1f, 0xff, 0x70, 0x0, 0x1b, 0xff, 0xff, 0xff, + 0xff, 0xc1, 0x6, 0xff, 0xf2, 0x0, 0x1d, 0xff, + 0xff, 0xfe, 0xff, 0xff, 0xd1, 0xaf, 0xfe, 0x0, + 0xb, 0xff, 0xfe, 0x60, 0x0, 0x3b, 0xff, 0xbe, + 0xff, 0xa0, 0x5, 0xff, 0xfe, 0x20, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xf6, 0x0, 0xcf, 0xff, 0x50, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x20, 0x1f, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xe0, 0x5, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xfb, 0x0, 0x7f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0x80, 0x8, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf4, + 0x0, 0x9f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x20, 0x8, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xf4, 0x0, 0x7f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x70, + 0x4, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xfa, 0x0, 0x1f, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xd0, 0x0, 0xbf, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x10, + 0x4, 0xff, 0xfe, 0x10, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xf5, 0x0, 0xa, 0xff, 0xfe, 0x50, 0x0, + 0x4d, 0xff, 0x8f, 0xff, 0x80, 0x0, 0x1c, 0xff, + 0xff, 0xfe, 0xff, 0xff, 0xd0, 0xbf, 0xfd, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xd2, 0x6, + 0xff, 0xf1, 0x0, 0x0, 0x3, 0x9d, 0xff, 0xeb, + 0x50, 0x0, 0x1f, 0xff, 0x70, + + /* U+03B2 "β" */ + 0x0, 0x0, 0x3, 0x8c, 0xff, 0xed, 0x93, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, + 0xfe, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0xef, + 0xff, 0x92, 0x0, 0x4, 0xdf, 0xff, 0x70, 0x0, + 0x7, 0xff, 0xf5, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf0, 0x0, 0xd, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xf4, 0x0, 0xf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf6, 0x0, 0x2f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf6, 0x0, + 0x3f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xf3, 0x0, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xc0, 0x0, 0x4f, 0xff, 0x30, 0x0, + 0x0, 0x2, 0xaf, 0xfe, 0x20, 0x0, 0x4f, 0xff, + 0x30, 0x5, 0x9a, 0xdf, 0xff, 0xb1, 0x0, 0x0, + 0x4f, 0xff, 0x30, 0xa, 0xff, 0xff, 0xd5, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0x30, 0xa, 0xff, 0xff, + 0xff, 0xd7, 0x0, 0x0, 0x4f, 0xff, 0x30, 0x0, + 0x1, 0x36, 0xdf, 0xff, 0xc1, 0x0, 0x4f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x8, 0xff, 0xfc, 0x0, + 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x60, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xd0, 0x4f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf0, 0x4f, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf2, + 0x4f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xf2, 0x4f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf0, 0x4f, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xb0, 0x4f, 0xff, + 0xfd, 0x10, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x50, + 0x4f, 0xff, 0xff, 0xd3, 0x0, 0x0, 0x9, 0xff, + 0xfb, 0x0, 0x4f, 0xff, 0x8f, 0xff, 0xd9, 0x9b, + 0xff, 0xff, 0xd1, 0x0, 0x4f, 0xff, 0x34, 0xef, + 0xff, 0xff, 0xff, 0xfc, 0x10, 0x0, 0x4f, 0xff, + 0x30, 0x6, 0xbe, 0xff, 0xd9, 0x40, 0x0, 0x0, + 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03B3 "γ" */ + 0x5f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf5, 0xe, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xe0, 0x9, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x90, 0x3, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x30, + 0x0, 0xdf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xfd, 0x0, 0x0, 0x7f, 0xff, 0x10, 0x0, 0x0, + 0x1, 0xff, 0xf7, 0x0, 0x0, 0x2f, 0xff, 0x70, + 0x0, 0x0, 0x6, 0xff, 0xf1, 0x0, 0x0, 0xc, + 0xff, 0xd0, 0x0, 0x0, 0xc, 0xff, 0xb0, 0x0, + 0x0, 0x6, 0xff, 0xf2, 0x0, 0x0, 0x2f, 0xff, + 0x50, 0x0, 0x0, 0x0, 0xff, 0xf8, 0x0, 0x0, + 0x7f, 0xff, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfd, + 0x0, 0x0, 0xdf, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x30, 0x3, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0x90, 0x9, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xe0, 0xe, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf4, 0x4f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xf9, 0xaf, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfc, 0x0, 0x0, + 0x0, 0x0, + + /* U+03B4 "δ" */ + 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x6f, 0xff, 0xfd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0x0, 0x0, 0x4, + 0xef, 0xfc, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1a, 0xff, 0xd2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5e, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xaf, 0xfa, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x8d, 0xff, 0xff, 0xe5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xda, 0xac, + 0xff, 0xfc, 0x10, 0x0, 0x0, 0xaf, 0xff, 0xd3, + 0x0, 0x0, 0x2b, 0xff, 0xe2, 0x0, 0x5, 0xff, + 0xfd, 0x10, 0x0, 0x0, 0x0, 0xaf, 0xfd, 0x10, + 0xc, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0x90, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf1, 0x5f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xf7, 0x7f, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfa, + 0x8f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xfc, 0x9f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xfd, 0x8f, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfc, 0x6f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfb, + 0x3f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf9, 0xe, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf5, 0x8, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xe0, 0x1, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x1, 0xcf, 0xff, 0x70, + 0x0, 0x6f, 0xff, 0xf9, 0x20, 0x0, 0x5e, 0xff, + 0xfc, 0x0, 0x0, 0x8, 0xff, 0xff, 0xfe, 0xef, + 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, 0x6e, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x6b, 0xdf, 0xfe, 0xb7, 0x10, 0x0, 0x0, + + /* U+03B5 "ε" */ + 0x0, 0x0, 0x29, 0xde, 0xfe, 0xc7, 0x10, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0xef, 0xfe, 0x51, 0x2, 0x8f, 0xff, 0x50, + 0x4, 0xff, 0xf4, 0x0, 0x0, 0x1, 0x92, 0x0, + 0x7, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xa3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1c, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x2, 0xef, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xfe, 0x60, 0x0, 0x0, + 0x5, 0xff, 0xfe, 0x61, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x7f, 0x50, + 0x8, 0xff, 0xfd, 0x40, 0x0, 0x4c, 0xff, 0xf8, + 0x0, 0xdf, 0xff, 0xff, 0xef, 0xff, 0xff, 0xe2, + 0x0, 0x2c, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x10, + 0x0, 0x0, 0x5a, 0xef, 0xfe, 0xb7, 0x20, 0x0, + + /* U+03B6 "ζ" */ + 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0x5, 0xdd, 0xdd, 0xdd, 0xde, 0xff, + 0xfd, 0x20, 0x0, 0x0, 0x0, 0x0, 0x4, 0xef, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xfe, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xb7, + 0x53, 0x10, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x40, 0x0, 0x0, 0x2e, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x17, + 0xce, 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x28, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x5d, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xec, 0x82, + 0x0, 0x0, + + /* U+03B7 "η" */ + 0x4f, 0xfe, 0x0, 0x17, 0xce, 0xfe, 0xc7, 0x10, + 0x0, 0x4f, 0xfe, 0x5, 0xef, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0x4f, 0xfe, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x40, 0x4f, 0xff, 0xff, 0xe6, 0x20, + 0x14, 0xcf, 0xff, 0xd0, 0x4f, 0xff, 0xfc, 0x10, + 0x0, 0x0, 0xd, 0xff, 0xf3, 0x4f, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf6, 0x4f, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf8, 0x4f, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf8, + 0x4f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf9, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf9, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf9, 0x4f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf9, 0x4f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xf9, 0x4f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf9, 0x4f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf9, 0x4f, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf9, + 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf9, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf9, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf9, 0x4f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf9, 0x4f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xf9, + + /* U+03B8 "θ" */ + 0x0, 0x0, 0x0, 0x49, 0xde, 0xfd, 0xb5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1b, 0xff, 0xff, 0xff, + 0xff, 0xe4, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xff, 0xef, 0xff, 0xff, 0x40, 0x0, 0x0, 0xc, + 0xff, 0xf9, 0x20, 0x1, 0x7f, 0xff, 0xf2, 0x0, + 0x0, 0x6f, 0xff, 0x70, 0x0, 0x0, 0x3, 0xff, + 0xfa, 0x0, 0x0, 0xdf, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x20, 0x3, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x70, 0x8, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xc0, + 0xb, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xf0, 0xd, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf2, 0xf, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf4, 0x1f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf5, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf7, 0x2f, 0xff, 0xec, 0xcc, + 0xcc, 0xcc, 0xcc, 0xcd, 0xff, 0xf7, 0x2f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, + 0x1f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf5, 0xf, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf4, 0xd, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf2, 0xb, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf0, + 0x8, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xc0, 0x3, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0x70, 0x0, 0xdf, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x20, 0x0, 0x6f, + 0xff, 0xa0, 0x0, 0x0, 0x5, 0xff, 0xfa, 0x0, + 0x0, 0xc, 0xff, 0xfb, 0x20, 0x1, 0x8f, 0xff, + 0xf2, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xef, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x1b, 0xff, + 0xff, 0xff, 0xff, 0xe4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4a, 0xdf, 0xfd, 0xb6, 0x0, 0x0, 0x0, + + /* U+03B9 "ι" */ + 0x5f, 0xff, 0x35, 0xff, 0xf3, 0x5f, 0xff, 0x35, + 0xff, 0xf3, 0x5f, 0xff, 0x35, 0xff, 0xf3, 0x5f, + 0xff, 0x35, 0xff, 0xf3, 0x5f, 0xff, 0x35, 0xff, + 0xf3, 0x5f, 0xff, 0x35, 0xff, 0xf3, 0x5f, 0xff, + 0x35, 0xff, 0xf3, 0x5f, 0xff, 0x35, 0xff, 0xf3, + 0x5f, 0xff, 0x35, 0xff, 0xf3, 0x5f, 0xff, 0x35, + 0xff, 0xf3, 0x5f, 0xff, 0x30, + + /* U+03BA "κ" */ + 0x6f, 0xff, 0x10, 0x0, 0x0, 0x1, 0xdf, 0xff, + 0xa0, 0x6f, 0xff, 0x10, 0x0, 0x0, 0x2d, 0xff, + 0xf9, 0x0, 0x6f, 0xff, 0x10, 0x0, 0x2, 0xef, + 0xff, 0x80, 0x0, 0x6f, 0xff, 0x10, 0x0, 0x2e, + 0xff, 0xf7, 0x0, 0x0, 0x6f, 0xff, 0x10, 0x2, + 0xef, 0xff, 0x60, 0x0, 0x0, 0x6f, 0xff, 0x10, + 0x2e, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x12, 0xef, 0xff, 0x40, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x4e, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd6, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x20, 0x7f, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x10, + 0xa, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x10, 0x0, 0xcf, 0xff, 0xa0, 0x0, 0x0, 0x6f, + 0xff, 0x10, 0x0, 0x1e, 0xff, 0xf7, 0x0, 0x0, + 0x6f, 0xff, 0x10, 0x0, 0x3, 0xff, 0xff, 0x40, + 0x0, 0x6f, 0xff, 0x10, 0x0, 0x0, 0x6f, 0xff, + 0xf2, 0x0, 0x6f, 0xff, 0x10, 0x0, 0x0, 0x8, + 0xff, 0xfd, 0x10, 0x6f, 0xff, 0x10, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xb0, 0x6f, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x1d, 0xff, 0xf9, + + /* U+03BB "λ" */ + 0x0, 0x0, 0xb, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfa, 0xbf, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xf4, 0x5f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xe0, 0xe, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x80, 0x9, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x20, 0x2, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfc, + 0x0, 0x0, 0xcf, 0xfd, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf6, 0x0, 0x0, 0x6f, 0xff, 0x40, 0x0, + 0x0, 0xa, 0xff, 0xf0, 0x0, 0x0, 0x1f, 0xff, + 0xa0, 0x0, 0x0, 0xf, 0xff, 0xa0, 0x0, 0x0, + 0xa, 0xff, 0xf0, 0x0, 0x0, 0x6f, 0xff, 0x40, + 0x0, 0x0, 0x4, 0xff, 0xf6, 0x0, 0x0, 0xcf, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfc, 0x0, + 0x2, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0x20, 0x9, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0x80, 0xe, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xe0, 0x5f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf4, + + /* U+03BC "μ" */ + 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf8, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf8, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf8, 0x4f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf8, 0x4f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xf8, 0x4f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf8, 0x4f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf8, 0x4f, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf8, + 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf8, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf8, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf8, 0x4f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf8, 0x4f, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xf8, 0x4f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf8, 0x4f, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf8, 0x4f, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf8, + 0x4f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xf8, 0x4f, 0xff, 0xff, 0xd6, 0x33, 0x6d, 0xff, + 0xff, 0xf8, 0x4f, 0xff, 0xef, 0xff, 0xff, 0xff, + 0xfe, 0xcf, 0xf8, 0x4f, 0xff, 0x4c, 0xff, 0xff, + 0xff, 0xe3, 0xaf, 0xf8, 0x4f, 0xff, 0x30, 0x6c, + 0xff, 0xd8, 0x10, 0xaf, 0xf8, 0x4f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03BD "ν" */ + 0x4f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf5, 0xe, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xe0, 0x8, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x90, 0x2, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x30, + 0x0, 0xcf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xfd, 0x0, 0x0, 0x6f, 0xff, 0x20, 0x0, 0x0, + 0x1, 0xff, 0xf7, 0x0, 0x0, 0x1f, 0xff, 0x80, + 0x0, 0x0, 0x6, 0xff, 0xf1, 0x0, 0x0, 0xa, + 0xff, 0xd0, 0x0, 0x0, 0xc, 0xff, 0xb0, 0x0, + 0x0, 0x4, 0xff, 0xf3, 0x0, 0x0, 0x2f, 0xff, + 0x50, 0x0, 0x0, 0x0, 0xef, 0xf9, 0x0, 0x0, + 0x7f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfe, + 0x0, 0x0, 0xdf, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x40, 0x3, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xa0, 0x9, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf0, 0xe, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xf4, 0x4f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xf9, 0x9f, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xfe, 0xef, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfd, 0x0, 0x0, + 0x0, 0x0, + + /* U+03BE "ξ" */ + 0x0, 0x0, 0x1, 0x7a, 0xdf, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xee, 0xee, + 0x10, 0x0, 0x7, 0xff, 0xfc, 0x51, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xc6, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x3a, + 0xef, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x2a, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xf9, 0x51, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xb1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xe4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfd, + 0x85, 0x30, 0x0, 0x0, 0x0, 0x1, 0xcf, 0xff, + 0xff, 0xff, 0xfc, 0x60, 0x0, 0x0, 0x0, 0x7e, + 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x4, 0x8b, 0xdf, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0x6c, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xec, 0x82, + 0x0, 0x0, + + /* U+03BF "ο" */ + 0x0, 0x0, 0x0, 0x5a, 0xdf, 0xfe, 0xb7, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x5e, 0xff, 0xff, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xef, 0xff, 0xff, 0xc1, 0x0, 0x0, 0x9f, + 0xff, 0xf7, 0x10, 0x0, 0x5d, 0xff, 0xfb, 0x0, + 0x3, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x70, 0xb, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xe0, 0x1f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf4, 0x4f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf8, + 0x7f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xfb, 0x8f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xfc, 0x9f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfd, 0x8f, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfc, + 0x7f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xfa, 0x4f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xf8, 0xf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf4, 0xb, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xe0, + 0x3, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x70, 0x0, 0x8f, 0xff, 0xf7, 0x10, 0x0, + 0x5d, 0xff, 0xfc, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xfe, 0xef, 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, + 0x6e, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6a, 0xdf, 0xfe, 0xb7, 0x10, + 0x0, 0x0, + + /* U+03C0 "π" */ + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xb2, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x1d, 0xdd, 0xdd, 0xff, 0xff, + 0xdd, 0xdd, 0xdd, 0xdd, 0xef, 0xff, 0xdd, 0xdd, + 0x90, 0x0, 0x0, 0xa, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0x0, 0x0, 0x0, + + /* U+03C1 "ρ" */ + 0x0, 0x0, 0x2, 0x8c, 0xef, 0xed, 0x94, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, + 0xff, 0xc2, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xfe, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x9f, + 0xff, 0xe5, 0x0, 0x2, 0x9f, 0xff, 0xf2, 0x0, + 0x2, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x4, 0xff, + 0xfd, 0x0, 0x8, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x50, 0xd, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xb0, 0x1f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf0, + 0x3f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf2, 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf4, 0x6f, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf5, 0x6f, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf4, + 0x7f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf3, 0x7f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf0, 0x7f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xc0, 0x7f, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x50, + 0x7f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xfd, 0x0, 0x7f, 0xff, 0xff, 0xd5, 0x0, 0x1, + 0x8f, 0xff, 0xf3, 0x0, 0x7f, 0xff, 0xef, 0xff, + 0xfe, 0xef, 0xff, 0xff, 0x60, 0x0, 0x7f, 0xff, + 0x2b, 0xff, 0xff, 0xff, 0xff, 0xe4, 0x0, 0x0, + 0x7f, 0xff, 0x10, 0x49, 0xdf, 0xfe, 0xb6, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+03C2 "ς" */ + 0x0, 0x0, 0x0, 0x0, 0x48, 0xcd, 0xff, 0xed, + 0xa5, 0x0, 0x0, 0x0, 0x6d, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x1c, 0xff, 0xff, 0xff, + 0xef, 0xff, 0xf5, 0x0, 0x1, 0xef, 0xff, 0xc6, + 0x10, 0x0, 0x3, 0x61, 0x0, 0xd, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xfe, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf9, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xfd, 0x84, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0xe9, 0x20, 0x0, 0x0, 0x0, 0x2, 0x9f, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x37, 0xbf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x9f, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x5, 0x44, 0x5b, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x6d, + 0xff, 0xec, 0x81, 0x0, 0x0, + + /* U+03C3 "σ" */ + 0x0, 0x0, 0x0, 0x6a, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x6, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x0, + 0xa, 0xff, 0xff, 0xfe, 0xef, 0xff, 0xff, 0xfd, + 0xdd, 0xdd, 0xa0, 0x9, 0xff, 0xfe, 0x71, 0x0, + 0x5, 0xdf, 0xff, 0xb0, 0x0, 0x0, 0x4, 0xff, + 0xfd, 0x20, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x70, + 0x0, 0x0, 0xcf, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xfe, 0x0, 0x0, 0x2f, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf4, 0x0, + 0x5, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x70, 0x0, 0x8f, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xfa, 0x0, 0x9, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xb0, 0x0, 0xaf, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xfb, 0x0, 0x9, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xa0, 0x0, 0x8f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf9, 0x0, 0x5, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x60, + 0x0, 0x2f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xf3, 0x0, 0x0, 0xcf, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, + 0x4, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x1, 0xcf, + 0xff, 0x50, 0x0, 0x0, 0x9, 0xff, 0xfe, 0x61, + 0x0, 0x5, 0xef, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xfe, 0xef, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x6b, 0xef, 0xfe, 0xb6, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+03C4 "τ" */ + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe1, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x1d, + 0xdd, 0xdd, 0xef, 0xff, 0xdd, 0xdd, 0xb0, 0x0, + 0x0, 0xa, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xfe, 0x0, 0x0, 0x0, + + /* U+03C5 "υ" */ + 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf4, 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf4, 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf4, 0x5f, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf4, 0x5f, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf4, 0x5f, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf4, 0x5f, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf4, 0x5f, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf4, + 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf4, 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf4, 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf4, 0x5f, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf4, 0x5f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xf3, 0x4f, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf2, 0x2f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, 0xf, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xc0, + 0xa, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0x70, 0x2, 0xff, 0xff, 0x91, 0x0, 0x2a, 0xff, + 0xfe, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xef, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x4, 0xef, 0xff, 0xff, + 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, 0x6, 0xbe, + 0xff, 0xda, 0x50, 0x0, 0x0, + + /* U+03C6 "φ" */ + 0x0, 0x0, 0x3, 0x9d, 0x90, 0x0, 0x8d, 0xff, + 0xda, 0x50, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0x60, 0xc, 0xff, 0xff, 0xff, 0xfc, 0x10, 0x0, + 0x0, 0xb, 0xff, 0xff, 0x20, 0x5f, 0xff, 0xff, + 0xff, 0xff, 0xd1, 0x0, 0x0, 0x9f, 0xff, 0xb3, + 0x0, 0x8f, 0xff, 0x70, 0x7, 0xff, 0xfb, 0x0, + 0x4, 0xff, 0xfa, 0x0, 0x0, 0x9f, 0xff, 0x0, + 0x0, 0x6f, 0xff, 0x40, 0xb, 0xff, 0xe0, 0x0, + 0x0, 0x9f, 0xfe, 0x0, 0x0, 0xc, 0xff, 0xb0, + 0x1f, 0xff, 0x80, 0x0, 0x0, 0xaf, 0xfd, 0x0, + 0x0, 0x7, 0xff, 0xf1, 0x5f, 0xff, 0x30, 0x0, + 0x0, 0xaf, 0xfd, 0x0, 0x0, 0x4, 0xff, 0xf5, + 0x7f, 0xff, 0x10, 0x0, 0x0, 0xaf, 0xfd, 0x0, + 0x0, 0x2, 0xff, 0xf7, 0x8f, 0xff, 0x0, 0x0, + 0x0, 0xaf, 0xfd, 0x0, 0x0, 0x2, 0xff, 0xf8, + 0x8f, 0xff, 0x0, 0x0, 0x0, 0xaf, 0xfd, 0x0, + 0x0, 0x3, 0xff, 0xf7, 0x7f, 0xff, 0x20, 0x0, + 0x0, 0xaf, 0xfd, 0x0, 0x0, 0x5, 0xff, 0xf5, + 0x5f, 0xff, 0x60, 0x0, 0x0, 0xaf, 0xfd, 0x0, + 0x0, 0x9, 0xff, 0xf1, 0x1f, 0xff, 0xc0, 0x0, + 0x0, 0xaf, 0xfd, 0x0, 0x0, 0xe, 0xff, 0xc0, + 0xb, 0xff, 0xf4, 0x0, 0x0, 0xaf, 0xfd, 0x0, + 0x0, 0x7f, 0xff, 0x60, 0x3, 0xff, 0xfe, 0x10, + 0x0, 0xaf, 0xfd, 0x0, 0x3, 0xff, 0xfd, 0x0, + 0x0, 0x9f, 0xff, 0xd2, 0x0, 0xaf, 0xfd, 0x0, + 0x4e, 0xff, 0xf3, 0x0, 0x0, 0xc, 0xff, 0xff, + 0x93, 0xaf, 0xfd, 0x4a, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x17, 0xce, 0xff, 0xff, 0xd8, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+03C7 "χ" */ + 0xc, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xfe, 0x0, 0x4f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x60, 0x0, 0xcf, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xe0, 0x0, + 0x4, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xf5, 0x0, 0x0, 0xc, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0xef, 0xfd, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0x70, 0x0, 0x0, 0x6f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0xbf, 0xfe, 0x0, 0x0, 0xe, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf7, 0x0, 0x7, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xe0, 0x0, 0xef, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0x60, 0x7f, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfe, 0x1e, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xfd, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf6, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xfa, 0xb, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x20, 0x3f, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0x90, 0x0, + 0xbf, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf2, 0x0, 0x3, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf9, 0x0, 0x0, 0xa, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0x10, 0x0, 0x0, + 0x2f, 0xff, 0xa0, 0x0, 0x0, 0x3f, 0xff, 0x90, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0x20, 0x0, 0xc, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfb, + 0x0, 0x4, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf4, 0x0, 0xdf, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xc0, 0x6f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x50, + + /* U+03C8 "ψ" */ + 0x9f, 0xfe, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x19, 0xff, 0xe0, 0x0, + 0x0, 0x8, 0xff, 0xf0, 0x0, 0x0, 0x6, 0xff, + 0xf1, 0x9f, 0xfe, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x19, 0xff, 0xe0, + 0x0, 0x0, 0x8, 0xff, 0xf0, 0x0, 0x0, 0x6, + 0xff, 0xf1, 0x9f, 0xfe, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x19, 0xff, + 0xe0, 0x0, 0x0, 0x8, 0xff, 0xf0, 0x0, 0x0, + 0x6, 0xff, 0xf1, 0x9f, 0xfe, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x19, + 0xff, 0xe0, 0x0, 0x0, 0x8, 0xff, 0xf0, 0x0, + 0x0, 0x6, 0xff, 0xf1, 0x9f, 0xfe, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x19, 0xff, 0xe0, 0x0, 0x0, 0x8, 0xff, 0xf0, + 0x0, 0x0, 0x6, 0xff, 0xf1, 0x9f, 0xfe, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x19, 0xff, 0xe0, 0x0, 0x0, 0x8, 0xff, + 0xf0, 0x0, 0x0, 0x6, 0xff, 0xf1, 0x8f, 0xff, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x7, 0xff, 0xf1, 0x0, 0x0, 0x8, + 0xff, 0xf0, 0x0, 0x0, 0x9, 0xff, 0xe0, 0x5f, + 0xff, 0x50, 0x0, 0x0, 0x8f, 0xff, 0x0, 0x0, + 0x0, 0xdf, 0xfc, 0x1, 0xff, 0xfc, 0x0, 0x0, + 0x8, 0xff, 0xf0, 0x0, 0x0, 0x5f, 0xff, 0x80, + 0x9, 0xff, 0xf9, 0x0, 0x0, 0x8f, 0xff, 0x0, + 0x0, 0x4f, 0xff, 0xf2, 0x0, 0xd, 0xff, 0xfd, + 0x61, 0x8, 0xff, 0xf0, 0x3, 0x9f, 0xff, 0xf8, + 0x0, 0x0, 0x2d, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x1a, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x7b, 0xde, 0xff, + 0xff, 0xfe, 0xda, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+03C9 "ω" */ + 0x0, 0x7, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xfb, 0x0, 0x0, 0x0, + 0xef, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf3, 0x0, 0x0, 0x7f, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xb0, 0x0, 0xd, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0x10, 0x3, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf7, + 0x0, 0x8f, 0xff, 0x20, 0x0, 0x0, 0x1, 0xdd, + 0xd4, 0x0, 0x0, 0x0, 0xe, 0xff, 0xc0, 0xc, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x50, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0x0, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xf3, 0x2f, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x63, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xf7, 0x4f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x83, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xf7, 0x3f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x60, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xf4, 0xd, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x10, 0x9f, 0xff, 0x30, 0x0, 0x0, 0xb, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0xe, 0xff, 0xd0, + 0x3, 0xff, 0xfb, 0x0, 0x0, 0x4, 0xff, 0xdf, + 0xf8, 0x0, 0x0, 0x8, 0xff, 0xf7, 0x0, 0xa, + 0xff, 0xfa, 0x0, 0x5, 0xff, 0xf1, 0xdf, 0xf8, + 0x0, 0x7, 0xff, 0xfd, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0xce, 0xff, 0xf6, 0x3, 0xff, 0xfe, 0xce, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x2d, 0xff, 0xff, + 0xff, 0xf7, 0x0, 0x4, 0xff, 0xff, 0xff, 0xfe, + 0x40, 0x0, 0x0, 0x0, 0x6, 0xce, 0xfe, 0xa3, + 0x0, 0x0, 0x1, 0x8d, 0xff, 0xc7, 0x10, 0x0, + 0x0, + + /* U+03CA "ϊ" */ + 0x1f, 0xff, 0x90, 0x0, 0xcf, 0xfe, 0x1f, 0xff, + 0x90, 0x0, 0xcf, 0xfe, 0x1f, 0xff, 0x90, 0x0, + 0xcf, 0xfe, 0x1f, 0xff, 0x90, 0x0, 0xcf, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x30, 0x0, + + /* U+03CB "ϋ" */ + 0x0, 0x8, 0xff, 0xf2, 0x0, 0x4f, 0xff, 0x60, + 0x0, 0x0, 0x8, 0xff, 0xf2, 0x0, 0x4f, 0xff, + 0x60, 0x0, 0x0, 0x8, 0xff, 0xf2, 0x0, 0x4f, + 0xff, 0x60, 0x0, 0x0, 0x8, 0xff, 0xf2, 0x0, + 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf4, + 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf4, 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf4, 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf4, 0x5f, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf4, 0x5f, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf4, 0x5f, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf4, 0x5f, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf4, 0x5f, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf4, + 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf4, 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf4, 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf4, 0x5f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf3, 0x4f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xf2, 0x2f, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, 0xf, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xc0, 0xa, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x70, + 0x2, 0xff, 0xff, 0x91, 0x0, 0x2a, 0xff, 0xfe, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xef, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x4, 0xef, 0xff, 0xff, 0xff, + 0xfd, 0x30, 0x0, 0x0, 0x0, 0x6, 0xbe, 0xff, + 0xda, 0x50, 0x0, 0x0, + + /* U+03CC "ό" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x46, 0x66, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5a, 0xdf, 0xfe, + 0xb7, 0x20, 0x0, 0x0, 0x0, 0x0, 0x5e, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0xef, 0xff, 0xff, 0xc1, 0x0, + 0x0, 0x9f, 0xff, 0xf7, 0x10, 0x0, 0x5d, 0xff, + 0xfb, 0x0, 0x3, 0xff, 0xfe, 0x20, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x70, 0xb, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xe0, 0x1f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf4, + 0x4f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf8, 0x7f, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xfb, 0x8f, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfc, 0x9f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfd, + 0x8f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xfc, 0x7f, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xfa, 0x4f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf8, 0xf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf4, + 0xb, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xe0, 0x3, 0xff, 0xfe, 0x20, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x70, 0x0, 0x8f, 0xff, 0xf7, + 0x10, 0x0, 0x5d, 0xff, 0xfc, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xfe, 0xef, 0xff, 0xff, 0xc1, 0x0, + 0x0, 0x0, 0x6e, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6a, 0xdf, 0xfe, + 0xb7, 0x10, 0x0, 0x0, + + /* U+03CD "ύ" */ + 0x0, 0x0, 0x0, 0x0, 0x5, 0x66, 0x64, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf4, 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf4, 0x5f, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf4, 0x5f, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf4, 0x5f, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf4, 0x5f, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf4, 0x5f, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf4, + 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf4, 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf4, 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf4, 0x5f, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf4, 0x5f, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf4, 0x5f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf3, 0x4f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf2, 0x2f, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf0, + 0xf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xc0, 0xa, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0x70, 0x2, 0xff, 0xff, 0x91, 0x0, 0x2a, + 0xff, 0xfe, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xef, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x4, 0xef, 0xff, + 0xff, 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, 0x6, + 0xbe, 0xff, 0xda, 0x50, 0x0, 0x0, + + /* U+03CE "ώ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x16, + 0x66, 0x62, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xb0, + 0x0, 0x0, 0xe, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x30, 0x0, + 0x7, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xfb, 0x0, 0x0, 0xdf, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xf1, 0x0, 0x3f, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x70, 0x8, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x1d, 0xdd, 0x40, 0x0, 0x0, 0x0, 0xef, + 0xfc, 0x0, 0xcf, 0xfd, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf0, + 0xf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x32, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf6, 0x3f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0x74, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xf8, 0x3f, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0x73, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf6, 0xf, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x40, 0xdf, 0xfc, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf1, 0x9, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0xef, 0xfd, 0x0, 0x3f, 0xff, 0xb0, 0x0, 0x0, + 0x4f, 0xfd, 0xff, 0x80, 0x0, 0x0, 0x8f, 0xff, + 0x70, 0x0, 0xaf, 0xff, 0xa0, 0x0, 0x5f, 0xff, + 0x1d, 0xff, 0x80, 0x0, 0x7f, 0xff, 0xd0, 0x0, + 0x1, 0xef, 0xff, 0xfc, 0xef, 0xff, 0x60, 0x3f, + 0xff, 0xec, 0xef, 0xff, 0xf3, 0x0, 0x0, 0x2, + 0xdf, 0xff, 0xff, 0xff, 0x70, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0xe4, 0x0, 0x0, 0x0, 0x0, 0x6c, + 0xef, 0xea, 0x30, 0x0, 0x0, 0x18, 0xdf, 0xfc, + 0x71, 0x0, 0x0, + + /* U+03F4 "ϴ" */ + 0x0, 0x0, 0x0, 0x2, 0x88, 0x81, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xfb, 0x0, 0x0, 0x4b, + 0xba, 0x0, 0x2f, 0xfe, 0x16, 0xbb, 0x87, 0xff, + 0xf0, 0x9, 0xff, 0x40, 0x9f, 0xfc, 0x7f, 0xff, + 0x1, 0xff, 0x90, 0x9, 0xff, 0xc7, 0xff, 0xf0, + 0x8f, 0xd0, 0x0, 0x9f, 0xfc +}; + + +/*--------------------- + * GLYPH DESCRIPTION + *--------------------*/ + +static const lv_font_fmt_txt_glyph_dsc_t glyph_dsc[] = { + {.bitmap_index = 0, .adv_w = 0, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0} /* id = 0 reserved */, + {.bitmap_index = 0, .adv_w = 178, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 0, .adv_w = 178, .box_w = 5, .box_h = 28, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 70, .adv_w = 227, .box_w = 12, .box_h = 11, .ofs_x = 1, .ofs_y = 17}, + {.bitmap_index = 136, .adv_w = 356, .box_w = 22, .box_h = 28, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 444, .adv_w = 356, .box_w = 20, .box_h = 36, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 804, .adv_w = 569, .box_w = 32, .box_h = 30, .ofs_x = 2, .ofs_y = -2}, + {.bitmap_index = 1284, .adv_w = 427, .box_w = 25, .box_h = 29, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 1647, .adv_w = 121, .box_w = 5, .box_h = 11, .ofs_x = 1, .ofs_y = 17}, + {.bitmap_index = 1675, .adv_w = 213, .box_w = 10, .box_h = 36, .ofs_x = 2, .ofs_y = -8}, + {.bitmap_index = 1855, .adv_w = 213, .box_w = 10, .box_h = 36, .ofs_x = 1, .ofs_y = -8}, + {.bitmap_index = 2035, .adv_w = 249, .box_w = 14, .box_h = 13, .ofs_x = 1, .ofs_y = 15}, + {.bitmap_index = 2126, .adv_w = 374, .box_w = 20, .box_h = 19, .ofs_x = 2, .ofs_y = 5}, + {.bitmap_index = 2316, .adv_w = 178, .box_w = 5, .box_h = 10, .ofs_x = 3, .ofs_y = -6}, + {.bitmap_index = 2341, .adv_w = 213, .box_w = 12, .box_h = 4, .ofs_x = 1, .ofs_y = 9}, + {.bitmap_index = 2365, .adv_w = 178, .box_w = 5, .box_h = 4, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 2375, .adv_w = 178, .box_w = 12, .box_h = 28, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2543, .adv_w = 356, .box_w = 20, .box_h = 28, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 2823, .adv_w = 356, .box_w = 11, .box_h = 28, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 2977, .adv_w = 356, .box_w = 20, .box_h = 28, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3257, .adv_w = 356, .box_w = 20, .box_h = 28, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3537, .adv_w = 356, .box_w = 21, .box_h = 28, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 3831, .adv_w = 356, .box_w = 20, .box_h = 28, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4111, .adv_w = 356, .box_w = 20, .box_h = 28, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4391, .adv_w = 356, .box_w = 20, .box_h = 28, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4671, .adv_w = 356, .box_w = 20, .box_h = 28, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4951, .adv_w = 356, .box_w = 20, .box_h = 28, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 5231, .adv_w = 178, .box_w = 5, .box_h = 21, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 5284, .adv_w = 178, .box_w = 5, .box_h = 27, .ofs_x = 3, .ofs_y = -6}, + {.bitmap_index = 5352, .adv_w = 374, .box_w = 20, .box_h = 20, .ofs_x = 2, .ofs_y = 4}, + {.bitmap_index = 5552, .adv_w = 374, .box_w = 20, .box_h = 12, .ofs_x = 2, .ofs_y = 8}, + {.bitmap_index = 5672, .adv_w = 374, .box_w = 20, .box_h = 20, .ofs_x = 2, .ofs_y = 4}, + {.bitmap_index = 5872, .adv_w = 356, .box_w = 20, .box_h = 28, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 6152, .adv_w = 650, .box_w = 38, .box_h = 36, .ofs_x = 2, .ofs_y = -8}, + {.bitmap_index = 6836, .adv_w = 427, .box_w = 28, .box_h = 28, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 7228, .adv_w = 427, .box_w = 23, .box_h = 28, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 7550, .adv_w = 462, .box_w = 26, .box_h = 28, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 7914, .adv_w = 462, .box_w = 24, .box_h = 28, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 8250, .adv_w = 427, .box_w = 22, .box_h = 28, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 8558, .adv_w = 392, .box_w = 20, .box_h = 28, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 8838, .adv_w = 498, .box_w = 27, .box_h = 28, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 9216, .adv_w = 462, .box_w = 23, .box_h = 28, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 9538, .adv_w = 178, .box_w = 5, .box_h = 28, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 9608, .adv_w = 320, .box_w = 16, .box_h = 28, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 9832, .adv_w = 427, .box_w = 25, .box_h = 28, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 10182, .adv_w = 356, .box_w = 18, .box_h = 28, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 10434, .adv_w = 533, .box_w = 28, .box_h = 28, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 10826, .adv_w = 462, .box_w = 23, .box_h = 28, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 11148, .adv_w = 498, .box_w = 29, .box_h = 28, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 11554, .adv_w = 427, .box_w = 22, .box_h = 28, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 11862, .adv_w = 498, .box_w = 29, .box_h = 30, .ofs_x = 1, .ofs_y = -2}, + {.bitmap_index = 12297, .adv_w = 462, .box_w = 26, .box_h = 28, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 12661, .adv_w = 427, .box_w = 24, .box_h = 28, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 12997, .adv_w = 392, .box_w = 24, .box_h = 28, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 13333, .adv_w = 462, .box_w = 23, .box_h = 28, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 13655, .adv_w = 427, .box_w = 27, .box_h = 28, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 14033, .adv_w = 604, .box_w = 38, .box_h = 28, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 14565, .adv_w = 427, .box_w = 27, .box_h = 28, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 14943, .adv_w = 427, .box_w = 27, .box_h = 28, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 15321, .adv_w = 392, .box_w = 24, .box_h = 28, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 15657, .adv_w = 178, .box_w = 9, .box_h = 36, .ofs_x = 2, .ofs_y = -8}, + {.bitmap_index = 15819, .adv_w = 178, .box_w = 12, .box_h = 28, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 15987, .adv_w = 178, .box_w = 9, .box_h = 36, .ofs_x = 0, .ofs_y = -8}, + {.bitmap_index = 16149, .adv_w = 300, .box_w = 17, .box_h = 16, .ofs_x = 1, .ofs_y = 13}, + {.bitmap_index = 16285, .adv_w = 356, .box_w = 24, .box_h = 3, .ofs_x = -1, .ofs_y = -8}, + {.bitmap_index = 16321, .adv_w = 213, .box_w = 9, .box_h = 6, .ofs_x = 1, .ofs_y = 23}, + {.bitmap_index = 16348, .adv_w = 356, .box_w = 20, .box_h = 21, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 16558, .adv_w = 356, .box_w = 19, .box_h = 28, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 16824, .adv_w = 320, .box_w = 19, .box_h = 21, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 17024, .adv_w = 356, .box_w = 19, .box_h = 28, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 17290, .adv_w = 356, .box_w = 20, .box_h = 21, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 17500, .adv_w = 178, .box_w = 13, .box_h = 28, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 17682, .adv_w = 356, .box_w = 19, .box_h = 29, .ofs_x = 1, .ofs_y = -8}, + {.bitmap_index = 17958, .adv_w = 356, .box_w = 18, .box_h = 28, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 18210, .adv_w = 142, .box_w = 5, .box_h = 28, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 18280, .adv_w = 142, .box_w = 9, .box_h = 36, .ofs_x = -2, .ofs_y = -8}, + {.bitmap_index = 18442, .adv_w = 320, .box_w = 18, .box_h = 28, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 18694, .adv_w = 142, .box_w = 5, .box_h = 28, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 18764, .adv_w = 533, .box_w = 29, .box_h = 21, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 19069, .adv_w = 356, .box_w = 18, .box_h = 21, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 19258, .adv_w = 356, .box_w = 20, .box_h = 21, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 19468, .adv_w = 356, .box_w = 19, .box_h = 29, .ofs_x = 2, .ofs_y = -8}, + {.bitmap_index = 19744, .adv_w = 356, .box_w = 19, .box_h = 29, .ofs_x = 1, .ofs_y = -8}, + {.bitmap_index = 20020, .adv_w = 213, .box_w = 12, .box_h = 21, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 20146, .adv_w = 320, .box_w = 18, .box_h = 21, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 20335, .adv_w = 178, .box_w = 11, .box_h = 29, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 20495, .adv_w = 356, .box_w = 18, .box_h = 21, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 20684, .adv_w = 320, .box_w = 20, .box_h = 21, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 20894, .adv_w = 462, .box_w = 29, .box_h = 21, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 21199, .adv_w = 320, .box_w = 20, .box_h = 21, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 21409, .adv_w = 320, .box_w = 20, .box_h = 29, .ofs_x = 0, .ofs_y = -8}, + {.bitmap_index = 21699, .adv_w = 320, .box_w = 20, .box_h = 21, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 21909, .adv_w = 213, .box_w = 12, .box_h = 36, .ofs_x = 1, .ofs_y = -8}, + {.bitmap_index = 22125, .adv_w = 166, .box_w = 4, .box_h = 36, .ofs_x = 3, .ofs_y = -8}, + {.bitmap_index = 22197, .adv_w = 213, .box_w = 13, .box_h = 36, .ofs_x = 0, .ofs_y = -8}, + {.bitmap_index = 22431, .adv_w = 374, .box_w = 21, .box_h = 8, .ofs_x = 1, .ofs_y = 10}, + {.bitmap_index = 22515, .adv_w = 178, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 22515, .adv_w = 356, .box_w = 22, .box_h = 29, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 22834, .adv_w = 356, .box_w = 20, .box_h = 20, .ofs_x = 1, .ofs_y = 4}, + {.bitmap_index = 23034, .adv_w = 356, .box_w = 23, .box_h = 28, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 23356, .adv_w = 167, .box_w = 4, .box_h = 36, .ofs_x = 3, .ofs_y = -8}, + {.bitmap_index = 23428, .adv_w = 356, .box_w = 20, .box_h = 36, .ofs_x = 1, .ofs_y = -8}, + {.bitmap_index = 23788, .adv_w = 213, .box_w = 12, .box_h = 4, .ofs_x = 1, .ofs_y = 25}, + {.bitmap_index = 23812, .adv_w = 472, .box_w = 30, .box_h = 29, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 24247, .adv_w = 240, .box_w = 15, .box_h = 15, .ofs_x = 0, .ofs_y = 14}, + {.bitmap_index = 24360, .adv_w = 356, .box_w = 18, .box_h = 18, .ofs_x = 2, .ofs_y = 1}, + {.bitmap_index = 24522, .adv_w = 374, .box_w = 20, .box_h = 13, .ofs_x = 2, .ofs_y = 8}, + {.bitmap_index = 24652, .adv_w = 213, .box_w = 12, .box_h = 4, .ofs_x = 1, .ofs_y = 9}, + {.bitmap_index = 24676, .adv_w = 472, .box_w = 30, .box_h = 29, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 25111, .adv_w = 256, .box_w = 12, .box_h = 11, .ofs_x = 2, .ofs_y = 18}, + {.bitmap_index = 25177, .adv_w = 374, .box_w = 20, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 25417, .adv_w = 213, .box_w = 13, .box_h = 15, .ofs_x = 0, .ofs_y = 14}, + {.bitmap_index = 25515, .adv_w = 213, .box_w = 13, .box_h = 15, .ofs_x = 0, .ofs_y = 14}, + {.bitmap_index = 25613, .adv_w = 356, .box_w = 18, .box_h = 29, .ofs_x = 2, .ofs_y = -8}, + {.bitmap_index = 25874, .adv_w = 344, .box_w = 23, .box_h = 36, .ofs_x = -1, .ofs_y = -8}, + {.bitmap_index = 26288, .adv_w = 179, .box_w = 5, .box_h = 4, .ofs_x = 3, .ofs_y = 12}, + {.bitmap_index = 26298, .adv_w = 356, .box_w = 18, .box_h = 18, .ofs_x = 2, .ofs_y = 1}, + {.bitmap_index = 26460, .adv_w = 534, .box_w = 31, .box_h = 31, .ofs_x = 2, .ofs_y = -2}, + {.bitmap_index = 26941, .adv_w = 213, .box_w = 8, .box_h = 6, .ofs_x = 4, .ofs_y = 24}, + {.bitmap_index = 26965, .adv_w = 427, .box_w = 28, .box_h = 28, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 27357, .adv_w = 502, .box_w = 32, .box_h = 28, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 27805, .adv_w = 536, .box_w = 32, .box_h = 28, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 28253, .adv_w = 246, .box_w = 13, .box_h = 28, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 28435, .adv_w = 496, .box_w = 32, .box_h = 28, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 28883, .adv_w = 548, .box_w = 36, .box_h = 28, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 29387, .adv_w = 482, .box_w = 31, .box_h = 28, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 29821, .adv_w = 142, .box_w = 15, .box_h = 29, .ofs_x = -3, .ofs_y = 0}, + {.bitmap_index = 30039, .adv_w = 427, .box_w = 28, .box_h = 28, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 30431, .adv_w = 427, .box_w = 23, .box_h = 28, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 30753, .adv_w = 353, .box_w = 19, .box_h = 28, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 31019, .adv_w = 428, .box_w = 28, .box_h = 28, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 31411, .adv_w = 427, .box_w = 22, .box_h = 28, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 31719, .adv_w = 392, .box_w = 24, .box_h = 28, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 32055, .adv_w = 462, .box_w = 23, .box_h = 28, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 32377, .adv_w = 498, .box_w = 29, .box_h = 28, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 32783, .adv_w = 178, .box_w = 5, .box_h = 28, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 32853, .adv_w = 427, .box_w = 25, .box_h = 28, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 33203, .adv_w = 428, .box_w = 27, .box_h = 28, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 33581, .adv_w = 533, .box_w = 28, .box_h = 28, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 33973, .adv_w = 462, .box_w = 23, .box_h = 28, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 34295, .adv_w = 416, .box_w = 22, .box_h = 28, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 34603, .adv_w = 498, .box_w = 29, .box_h = 28, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 35009, .adv_w = 462, .box_w = 23, .box_h = 28, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 35331, .adv_w = 427, .box_w = 22, .box_h = 28, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 35639, .adv_w = 396, .box_w = 22, .box_h = 28, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 35947, .adv_w = 392, .box_w = 24, .box_h = 28, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 36283, .adv_w = 427, .box_w = 27, .box_h = 28, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 36661, .adv_w = 511, .box_w = 30, .box_h = 31, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 37126, .adv_w = 427, .box_w = 27, .box_h = 28, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 37504, .adv_w = 535, .box_w = 29, .box_h = 28, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 37910, .adv_w = 478, .box_w = 28, .box_h = 28, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 38302, .adv_w = 178, .box_w = 12, .box_h = 34, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 38506, .adv_w = 427, .box_w = 27, .box_h = 34, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 38965, .adv_w = 370, .box_w = 21, .box_h = 30, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 39280, .adv_w = 285, .box_w = 16, .box_h = 30, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 39520, .adv_w = 356, .box_w = 18, .box_h = 37, .ofs_x = 2, .ofs_y = -8}, + {.bitmap_index = 39853, .adv_w = 142, .box_w = 8, .box_h = 29, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 39969, .adv_w = 350, .box_w = 18, .box_h = 30, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 40239, .adv_w = 370, .box_w = 21, .box_h = 21, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 40460, .adv_w = 368, .box_w = 20, .box_h = 36, .ofs_x = 2, .ofs_y = -8}, + {.bitmap_index = 40820, .adv_w = 320, .box_w = 20, .box_h = 29, .ofs_x = 0, .ofs_y = -8}, + {.bitmap_index = 41110, .adv_w = 356, .box_w = 20, .box_h = 28, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 41390, .adv_w = 285, .box_w = 16, .box_h = 21, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 41558, .adv_w = 282, .box_w = 17, .box_h = 36, .ofs_x = 1, .ofs_y = -8}, + {.bitmap_index = 41864, .adv_w = 356, .box_w = 18, .box_h = 29, .ofs_x = 2, .ofs_y = -8}, + {.bitmap_index = 42125, .adv_w = 356, .box_w = 20, .box_h = 28, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 42405, .adv_w = 142, .box_w = 5, .box_h = 21, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 42458, .adv_w = 319, .box_w = 18, .box_h = 21, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 42647, .adv_w = 320, .box_w = 20, .box_h = 28, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 42927, .adv_w = 356, .box_w = 18, .box_h = 29, .ofs_x = 2, .ofs_y = -8}, + {.bitmap_index = 43188, .adv_w = 320, .box_w = 20, .box_h = 21, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 43398, .adv_w = 287, .box_w = 17, .box_h = 36, .ofs_x = 1, .ofs_y = -8}, + {.bitmap_index = 43704, .adv_w = 356, .box_w = 20, .box_h = 21, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 43914, .adv_w = 442, .box_w = 27, .box_h = 21, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 44198, .adv_w = 364, .box_w = 20, .box_h = 29, .ofs_x = 2, .ofs_y = -8}, + {.bitmap_index = 44488, .adv_w = 308, .box_w = 18, .box_h = 29, .ofs_x = 1, .ofs_y = -8}, + {.bitmap_index = 44749, .adv_w = 395, .box_w = 23, .box_h = 21, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 44991, .adv_w = 253, .box_w = 15, .box_h = 21, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 45149, .adv_w = 350, .box_w = 18, .box_h = 21, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 45338, .adv_w = 415, .box_w = 24, .box_h = 29, .ofs_x = 1, .ofs_y = -8}, + {.bitmap_index = 45686, .adv_w = 336, .box_w = 21, .box_h = 29, .ofs_x = 0, .ofs_y = -8}, + {.bitmap_index = 45991, .adv_w = 456, .box_w = 25, .box_h = 29, .ofs_x = 2, .ofs_y = -8}, + {.bitmap_index = 46354, .adv_w = 500, .box_w = 29, .box_h = 21, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 46659, .adv_w = 142, .box_w = 12, .box_h = 28, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 46827, .adv_w = 350, .box_w = 18, .box_h = 28, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 47079, .adv_w = 356, .box_w = 20, .box_h = 30, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 47379, .adv_w = 350, .box_w = 18, .box_h = 30, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 47649, .adv_w = 500, .box_w = 29, .box_h = 30, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 48084, .adv_w = 213, .box_w = 15, .box_h = 6, .ofs_x = -1, .ofs_y = 24} +}; + +/*--------------------- + * CHARACTER MAPPING + *--------------------*/ + +static const uint8_t glyph_id_ofs_list_1[] = { + 0, 0, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 0, + 13, 14, 15, 16, 0, 17, 18, 19, + 0, 0, 0, 20, 0, 21 +}; + +static const uint8_t glyph_id_ofs_list_2[] = { + 0, 0, 1, 0, 2, 3, 4, 0, + 5 +}; + +/*Collect the unicode lists and glyph_id offsets*/ +static const lv_font_fmt_txt_cmap_t cmaps[] = +{ + { + .range_start = 32, .range_length = 95, .glyph_id_start = 1, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 160, .range_length = 30, .glyph_id_start = 96, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_1, .list_length = 30, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 900, .range_length = 9, .glyph_id_start = 118, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_2, .list_length = 9, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 910, .range_length = 20, .glyph_id_start = 124, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 931, .range_length = 44, .glyph_id_start = 144, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 1012, .range_length = 1, .glyph_id_start = 188, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + } +}; + + + +/*-------------------- + * ALL CUSTOM DATA + *--------------------*/ + +#if LVGL_VERSION_MAJOR == 8 +/*Store all the custom data of the font*/ +static lv_font_fmt_txt_glyph_cache_t cache; +#endif + +#if LVGL_VERSION_MAJOR >= 8 +static const lv_font_fmt_txt_dsc_t font_dsc = { +#else +static lv_font_fmt_txt_dsc_t font_dsc = { +#endif + .glyph_bitmap = glyph_bitmap, + .glyph_dsc = glyph_dsc, + .cmaps = cmaps, + .kern_dsc = NULL, + .kern_scale = 0, + .cmap_num = 6, + .bpp = 4, + .kern_classes = 0, + .bitmap_format = 0, +#if LVGL_VERSION_MAJOR == 8 + .cache = &cache +#endif + +}; + +extern const lv_font_t lv_font_montserrat_40; + + +/*----------------- + * PUBLIC FONT + *----------------*/ + +/*Initialize a public general font descriptor*/ +#if LVGL_VERSION_MAJOR >= 8 +const lv_font_t lv_font_arial_40 = { +#else +lv_font_t lv_font_arial_40 = { +#endif + .get_glyph_dsc = lv_font_get_glyph_dsc_fmt_txt, /*Function pointer to get glyph's data*/ + .get_glyph_bitmap = lv_font_get_bitmap_fmt_txt, /*Function pointer to get glyph's bitmap*/ + .line_height = 42, /*The maximum line height required by the font*/ + .base_line = 8, /*Baseline measured from the bottom of the line*/ +#if !(LVGL_VERSION_MAJOR == 6 && LVGL_VERSION_MINOR == 0) + .subpx = LV_FONT_SUBPX_NONE, +#endif +#if LV_VERSION_CHECK(7, 4, 0) || LVGL_VERSION_MAJOR >= 8 + .underline_position = -4, + .underline_thickness = 3, +#endif + //.static_bitmap = 0, + .dsc = &font_dsc, /*The custom font data. Will be accessed by `get_glyph_bitmap/dsc` */ +#if LV_VERSION_CHECK(8, 2, 0) || LVGL_VERSION_MAJOR >= 9 + .fallback = &lv_font_montserrat_40, +#endif + .user_data = NULL, +}; + + + +#endif /*#if LV_FONT_ARIAL_40*/ diff --git a/src/fonts/lv_font_arial_42.c b/src/fonts/lv_font_arial_42.c new file mode 100644 index 0000000000..b1c90acf28 --- /dev/null +++ b/src/fonts/lv_font_arial_42.c @@ -0,0 +1,7541 @@ +/******************************************************************************* + * Size: 42 px + * Bpp: 4 + * Opts: --bpp 4 --size 42 --no-compress --stride 1 --align 1 --font Arial Greek Regular.ttf --range 32-127,160-255,880-1023 --format lvgl -o lv_font_arial_42.c + ******************************************************************************/ + +#ifdef __has_include + #if __has_include("lvgl.h") + #ifndef LV_LVGL_H_INCLUDE_SIMPLE + #define LV_LVGL_H_INCLUDE_SIMPLE + #endif + #endif +#endif + +#ifdef LV_LVGL_H_INCLUDE_SIMPLE + #include "lvgl.h" +#else + #include "lvgl/lvgl.h" +#endif + + + +#ifndef LV_FONT_ARIAL_42 +#define LV_FONT_ARIAL_42 1 +#endif + +#if LV_FONT_ARIAL_42 + +/*----------------- + * BITMAPS + *----------------*/ + +/*Store the image of the glyphs*/ +static LV_ATTRIBUTE_LARGE_CONST const uint8_t glyph_bitmap[] = { + /* U+0020 " " */ + + /* U+0021 "!" */ + 0x7f, 0xff, 0xf2, 0x7f, 0xff, 0xf2, 0x7f, 0xff, + 0xf2, 0x7f, 0xff, 0xf2, 0x7f, 0xff, 0xf2, 0x7f, + 0xff, 0xf2, 0x7f, 0xff, 0xf1, 0x6f, 0xff, 0xf0, + 0x5f, 0xff, 0xf0, 0x3f, 0xff, 0xe0, 0x2f, 0xff, + 0xd0, 0x1f, 0xff, 0xc0, 0xf, 0xff, 0xb0, 0xf, + 0xff, 0xa0, 0xe, 0xff, 0x90, 0xd, 0xff, 0x80, + 0xb, 0xff, 0x70, 0xa, 0xff, 0x60, 0x9, 0xff, + 0x50, 0x8, 0xff, 0x40, 0x7, 0xff, 0x20, 0x6, + 0xff, 0x10, 0x1, 0x55, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0x22, 0x20, 0x4f, 0xff, + 0xf0, 0x4f, 0xff, 0xf0, 0x4f, 0xff, 0xf0, 0x4f, + 0xff, 0xf0, + + /* U+0022 "\"" */ + 0xf, 0xff, 0xf2, 0x4, 0xff, 0xff, 0xf, 0xff, + 0xf2, 0x4, 0xff, 0xff, 0xf, 0xff, 0xf2, 0x4, + 0xff, 0xff, 0xf, 0xff, 0xf2, 0x4, 0xff, 0xff, + 0xf, 0xff, 0xf2, 0x3, 0xff, 0xff, 0xe, 0xff, + 0xf0, 0x2, 0xff, 0xfd, 0xc, 0xff, 0xe0, 0x0, + 0xff, 0xfa, 0x9, 0xff, 0xb0, 0x0, 0xcf, 0xf8, + 0x6, 0xff, 0x80, 0x0, 0x9f, 0xf5, 0x3, 0xff, + 0x60, 0x0, 0x6f, 0xf2, 0x0, 0x88, 0x20, 0x0, + 0x28, 0x80, + + /* U+0023 "#" */ + 0x0, 0x0, 0x0, 0x0, 0x47, 0x74, 0x0, 0x0, + 0x0, 0x77, 0x70, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0x60, 0x0, 0x0, 0x2f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xf2, 0x0, 0x0, 0x5, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0x0, 0x0, 0x0, 0x9f, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xb0, 0x0, 0x0, 0xc, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf8, 0x0, + 0x0, 0x0, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0x50, 0x0, 0x0, 0x3f, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf1, 0x0, 0x0, + 0x6, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xfe, 0x0, 0x0, 0x0, 0xaf, 0xf7, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0xff, 0xf1, 0x0, + 0x0, 0x7, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xfd, 0x0, 0x0, 0x0, 0xbf, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xa0, 0x0, 0x0, + 0xe, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xf6, 0x0, 0x0, 0x2, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0x30, 0x0, 0x0, 0x5f, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf0, + 0x0, 0x0, 0x9, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xfc, 0x0, 0x0, 0x0, 0xcf, 0xf5, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0x0, 0x2, 0xff, + 0xf0, 0x0, 0x0, 0x9, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xfc, 0x0, 0x0, 0x0, 0xcf, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0x90, + 0x0, 0x0, 0xf, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xf5, 0x0, 0x0, 0x2, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0x20, 0x0, + 0x0, 0x6f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xf0, 0x0, 0x0, 0x9, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xfc, 0x0, 0x0, 0x0, + 0xcf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0x90, 0x0, 0x0, 0xf, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xf5, 0x0, 0x0, 0x2, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0024 "$" */ + 0x0, 0x0, 0x0, 0x0, 0x3, 0x85, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x16, 0x9d, 0xfe, 0xa7, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xb2, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xe8, 0xaf, 0xd9, 0xef, 0xff, 0xf3, 0x0, 0x0, + 0xcf, 0xff, 0xa0, 0x7, 0xfb, 0x1, 0xcf, 0xff, + 0xc0, 0x0, 0x3f, 0xff, 0xb0, 0x0, 0x7f, 0xb0, + 0x1, 0xff, 0xff, 0x30, 0x8, 0xff, 0xf3, 0x0, + 0x7, 0xfb, 0x0, 0x8, 0xff, 0xf8, 0x0, 0xbf, + 0xff, 0x0, 0x0, 0x7f, 0xb0, 0x0, 0x3f, 0xec, + 0x60, 0xc, 0xff, 0xe0, 0x0, 0x7, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x10, 0x0, + 0x7f, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xf7, 0x0, 0x7, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xf3, 0x0, 0x7f, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf7, 0x7, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, + 0xff, 0xff, 0xdf, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xdf, 0xff, 0xff, 0xff, 0xea, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7e, 0xff, 0xff, + 0xff, 0xff, 0xe6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0x9e, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xda, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xfb, + 0x1, 0x9f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xb0, 0x0, 0x6f, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xfb, 0x0, 0x0, 0xdf, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xb0, + 0x0, 0x8, 0xff, 0xf6, 0x27, 0xad, 0x50, 0x0, + 0x7, 0xfb, 0x0, 0x0, 0x5f, 0xff, 0x75, 0xff, + 0xf9, 0x0, 0x0, 0x7f, 0xb0, 0x0, 0x6, 0xff, + 0xf6, 0x2f, 0xff, 0xe0, 0x0, 0x7, 0xfb, 0x0, + 0x0, 0x9f, 0xff, 0x40, 0xef, 0xff, 0x50, 0x0, + 0x7f, 0xb0, 0x0, 0xe, 0xff, 0xf0, 0x8, 0xff, + 0xfd, 0x10, 0x7, 0xfb, 0x0, 0x9, 0xff, 0xf9, + 0x0, 0x1e, 0xff, 0xfc, 0x20, 0x7f, 0xb0, 0x1a, + 0xff, 0xff, 0x20, 0x0, 0x4f, 0xff, 0xff, 0xbb, + 0xfd, 0xaf, 0xff, 0xff, 0x50, 0x0, 0x0, 0x4e, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x18, 0xef, 0xff, 0xff, 0xff, 0xfb, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x36, 0xcf, + 0xd6, 0x51, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0025 "%" */ + 0x0, 0x0, 0x15, 0x76, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0x88, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xe5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x61, 0x17, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0x80, 0x0, 0x8, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0xa, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xf1, 0x0, 0x0, 0x2f, + 0xff, 0x0, 0x0, 0x0, 0x3, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xfe, 0x0, 0x0, 0x0, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0xbf, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xc0, 0x0, 0x0, + 0xd, 0xff, 0x50, 0x0, 0x0, 0x3f, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfc, 0x0, 0x0, + 0x0, 0xdf, 0xf5, 0x0, 0x0, 0xc, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xc0, 0x0, + 0x0, 0xe, 0xff, 0x40, 0x0, 0x4, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xfe, 0x0, + 0x0, 0x1, 0xff, 0xf2, 0x0, 0x0, 0xcf, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf3, + 0x0, 0x0, 0x5f, 0xfe, 0x0, 0x0, 0x5f, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xc0, 0x0, 0x1d, 0xff, 0x80, 0x0, 0xd, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xd8, 0x9e, 0xff, 0xd0, 0x0, 0x6, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3e, 0xff, 0xff, 0xff, 0xc1, 0x0, 0x0, 0xef, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x18, 0xdf, 0xfc, 0x60, 0x0, 0x0, 0x6f, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0x10, 0x0, 0x5, 0xbe, 0xfe, 0x92, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0x80, 0x0, 0xa, 0xff, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xf1, 0x0, 0x8, 0xff, 0xfa, 0x8b, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xf8, 0x0, 0x2, 0xff, 0xf5, 0x0, 0x7, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xfe, 0x10, 0x0, 0x8f, 0xfb, 0x0, 0x0, + 0xd, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0x70, 0x0, 0xc, 0xff, 0x70, 0x0, + 0x0, 0x9f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xe0, 0x0, 0x0, 0xff, 0xf4, 0x0, + 0x0, 0x7, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xf6, 0x0, 0x0, 0xf, 0xff, 0x30, + 0x0, 0x0, 0x6f, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xfe, 0x0, 0x0, 0x0, 0xff, 0xf3, + 0x0, 0x0, 0x6, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0x60, 0x0, 0x0, 0xe, 0xff, + 0x40, 0x0, 0x0, 0x7f, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xd0, 0x0, 0x0, 0x0, 0xcf, + 0xf6, 0x0, 0x0, 0xa, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xf5, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xa0, 0x0, 0x0, 0xef, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x40, 0x0, 0x8f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xa8, 0xcf, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4b, 0xef, 0xd9, 0x20, 0x0, + + /* U+0026 "&" */ + 0x0, 0x0, 0x0, 0x0, 0x1, 0x57, 0x75, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2b, 0xff, 0xff, 0xff, 0xb2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfc, 0x99, 0xef, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf6, 0x0, 0x1, 0xbf, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfa, + 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, 0x0, + 0xc, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf7, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xd0, 0x0, 0x0, 0x2f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x80, 0x0, + 0xb, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0x60, 0xb, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0x7e, 0xff, 0xfe, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, + 0xff, 0xfd, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7e, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xcf, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xf7, 0xdf, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xc2, 0x2, 0xef, 0xff, 0xd1, 0x0, 0xf, + 0xd9, 0x60, 0x0, 0x0, 0xef, 0xff, 0xb0, 0x0, + 0x4, 0xff, 0xff, 0xb0, 0x4, 0xff, 0xfc, 0x0, + 0x0, 0x7f, 0xff, 0xd0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0x80, 0x9f, 0xff, 0x80, 0x0, 0xd, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x5f, + 0xff, 0xf2, 0x0, 0x1, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x2f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xff, 0xff, 0x40, 0x0, 0x1, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0xf, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x3, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x4e, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0xa, 0xff, 0xff, + 0x91, 0x0, 0x2, 0x9f, 0xff, 0xfd, 0xef, 0xff, + 0xf8, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfc, 0xbd, + 0xff, 0xff, 0xfc, 0x13, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x1c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x3, 0xef, 0xff, 0x60, 0x0, 0x0, 0x6, + 0xdf, 0xff, 0xff, 0xff, 0xa3, 0x0, 0x0, 0x2, + 0xdf, 0x90, 0x0, 0x0, 0x0, 0x0, 0x25, 0x67, + 0x64, 0x0, 0x0, 0x0, 0x0, 0x0, 0x70, 0x0, + + /* U+0027 "'" */ + 0x1f, 0xff, 0xf1, 0x1f, 0xff, 0xf1, 0x1f, 0xff, + 0xf1, 0x1f, 0xff, 0xf1, 0x1f, 0xff, 0xf1, 0xf, + 0xff, 0xf0, 0xd, 0xff, 0xd0, 0xa, 0xff, 0xa0, + 0x7, 0xff, 0x70, 0x5, 0xff, 0x40, 0x1, 0x88, + 0x10, + + /* U+0028 "(" */ + 0x0, 0x0, 0x0, 0x8, 0xff, 0x20, 0x0, 0x0, + 0x3, 0xff, 0x90, 0x0, 0x0, 0x0, 0xef, 0xe1, + 0x0, 0x0, 0x0, 0x8f, 0xf7, 0x0, 0x0, 0x0, + 0x2f, 0xfe, 0x0, 0x0, 0x0, 0xb, 0xff, 0x80, + 0x0, 0x0, 0x3, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0xbf, 0xfa, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x40, + 0x0, 0x0, 0x8, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0xef, 0xfa, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x60, + 0x0, 0x0, 0x8, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0xcf, 0xfe, 0x0, 0x0, 0x0, 0xf, 0xff, 0xb0, + 0x0, 0x0, 0x2, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x70, 0x0, 0x0, 0x5, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x60, 0x0, 0x0, + 0x7, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x60, 0x0, 0x0, 0x5, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x80, 0x0, 0x0, 0x2, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0xf, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0xef, 0xfa, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x50, 0x0, 0x0, 0x0, 0xbf, 0xfa, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf1, 0x0, 0x0, 0x0, 0xb, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x3f, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xe1, 0x0, 0x0, 0x0, 0x4, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x8, 0xff, 0x20, + + /* U+0029 ")" */ + 0x3f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf3, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0x80, 0x0, 0x0, 0x0, 0xe, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x8f, 0xfb, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x20, 0x0, 0x0, 0x0, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x30, 0x0, 0x0, 0x2, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0x30, 0x0, 0x0, + 0x6, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x60, 0x0, 0x0, 0x5, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0x60, 0x0, 0x0, 0x6, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x40, 0x0, + 0x0, 0xa, 0xff, 0xf1, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x0, 0x0, 0x0, 0xf, 0xff, 0xc0, 0x0, + 0x0, 0x2, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x30, 0x0, 0x0, 0xb, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0x20, 0x0, 0x0, 0xb, 0xff, 0xa0, 0x0, + 0x0, 0x1, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x8f, + 0xfa, 0x0, 0x0, 0x0, 0x1e, 0xff, 0x20, 0x0, + 0x0, 0x8, 0xff, 0x80, 0x0, 0x0, 0x1, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x9f, 0xf4, 0x0, 0x0, + 0x0, 0x3f, 0xf8, 0x0, 0x0, 0x0, 0x0, + + /* U+002A "*" */ + 0x0, 0x0, 0x5, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0x70, 0x0, 0x0, 0xa, 0x71, 0x1, + 0xff, 0x50, 0x5, 0xb2, 0x2f, 0xff, 0xb4, 0xff, + 0x58, 0xff, 0xf7, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x3, 0x7b, 0xef, 0xff, 0xff, 0xda, + 0x51, 0x0, 0x0, 0x1e, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x1, 0xdf, 0xec, 0xff, 0x40, 0x0, 0x0, + 0xc, 0xff, 0x73, 0xff, 0xf3, 0x0, 0x0, 0x9f, + 0xfd, 0x0, 0x9f, 0xfe, 0x10, 0x0, 0x4e, 0xf4, + 0x0, 0xd, 0xf8, 0x0, 0x0, 0x1, 0x50, 0x0, + 0x3, 0x30, 0x0, + + /* U+002B "+" */ + 0x0, 0x0, 0x0, 0x0, 0x4a, 0xaa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x46, 0x66, 0x66, 0x66, + 0xbf, 0xff, 0x66, 0x66, 0x66, 0x66, 0x1a, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf3, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x3a, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, + + /* U+002C "," */ + 0x2, 0x22, 0x25, 0xff, 0xfd, 0x5f, 0xff, 0xd5, + 0xff, 0xfd, 0x5f, 0xff, 0xd0, 0x4, 0xfc, 0x0, + 0x6f, 0xb0, 0xc, 0xf7, 0x7, 0xff, 0x15, 0xff, + 0x50, 0xa, 0x30, 0x0, + + /* U+002D "-" */ + 0x7a, 0xaa, 0xaa, 0xaa, 0xaa, 0xa7, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xfa, + + /* U+002E "." */ + 0x2, 0x22, 0x24, 0xff, 0xff, 0x4f, 0xff, 0xf4, + 0xff, 0xff, 0x4f, 0xff, 0xf0, + + /* U+002F "/" */ + 0x0, 0x0, 0x0, 0x0, 0x28, 0x84, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xf1, 0x0, 0x0, 0x0, 0x2, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0x80, 0x0, 0x0, + 0x0, 0xb, 0xff, 0x30, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xf1, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x6, 0xff, 0x80, 0x0, + 0x0, 0x0, 0xb, 0xff, 0x30, 0x0, 0x0, 0x0, + 0xf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf1, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x6, 0xff, 0x80, + 0x0, 0x0, 0x0, 0xb, 0xff, 0x30, 0x0, 0x0, + 0x0, 0xf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf1, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0x80, 0x0, 0x0, 0x0, 0xb, 0xff, 0x40, 0x0, + 0x0, 0x0, 0xf, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf1, 0x0, 0x0, + 0x0, 0x0, + + /* U+0030 "0" */ + 0x0, 0x0, 0x0, 0x17, 0xce, 0xfe, 0xc8, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xf8, 0x20, 0x26, 0xef, 0xff, + 0xb0, 0x0, 0x0, 0x1f, 0xff, 0xf3, 0x0, 0x0, + 0x1, 0xdf, 0xff, 0x50, 0x0, 0x9, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xfd, 0x0, 0x0, + 0xef, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf3, 0x0, 0x3f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0x80, 0x8, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xfc, 0x0, 0xbf, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf0, 0xd, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0x10, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xf3, 0xf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0x51, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xf5, 0x2f, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x62, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf6, + 0x1f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x61, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xf5, 0xf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x40, + 0xef, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xf2, 0xc, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x0, 0x9f, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xe0, 0x6, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xfa, 0x0, 0x1f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x50, 0x0, 0xcf, 0xff, 0x10, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf1, 0x0, 0x5, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf9, + 0x0, 0x0, 0xc, 0xff, 0xfa, 0x0, 0x0, 0x7, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x2e, 0xff, 0xff, + 0xa8, 0x9e, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x19, 0xef, 0xff, 0xff, 0xfb, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x46, + 0x76, 0x41, 0x0, 0x0, 0x0, 0x0, + + /* U+0031 "1" */ + 0x0, 0x0, 0x0, 0x0, 0xe, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xfb, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xfb, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xfb, 0x0, 0x1, + 0xbf, 0xff, 0xff, 0xfb, 0x0, 0x7f, 0xff, 0xfe, + 0xff, 0xfb, 0x3e, 0xff, 0xff, 0xd2, 0xff, 0xfb, + 0x5f, 0xff, 0xf9, 0x0, 0xff, 0xfb, 0x5f, 0xfc, + 0x30, 0x0, 0xff, 0xfb, 0x5b, 0x40, 0x0, 0x0, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xfb, + + /* U+0032 "2" */ + 0x0, 0x0, 0x0, 0x39, 0xce, 0xff, 0xda, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xc6, 0x20, 0x14, 0xaf, 0xff, + 0xf8, 0x0, 0x0, 0xdf, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf3, 0x0, 0x4f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xa0, 0x9, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xfe, 0x0, 0xdf, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf1, 0xa, 0xce, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2e, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2e, 0xff, 0xfd, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, 0xfd, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xfc, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xcf, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xdf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xe3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xfc, 0x88, 0x88, 0x88, 0x88, + 0x88, 0x88, 0x88, 0x14, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x3a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf3, + + /* U+0033 "3" */ + 0x0, 0x0, 0x0, 0x39, 0xdf, 0xfe, 0xb7, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x3, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xc4, 0x10, 0x27, 0xff, 0xff, + 0x90, 0x0, 0x0, 0xaf, 0xff, 0xa0, 0x0, 0x0, + 0x2, 0xef, 0xff, 0x30, 0x0, 0x1f, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xfa, 0x0, 0x7, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xe0, 0x0, 0xaf, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x0, 0x0, 0x25, 0x70, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x26, 0xcf, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xd3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xfb, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xec, 0xdf, 0xff, 0xff, 0xc1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x10, 0x0, 0x6, 0xef, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xdf, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x70, 0x0, 0x11, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf8, 0x1d, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0x60, 0xef, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf4, 0xa, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xfe, 0x0, 0x3f, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0x70, 0x0, 0x9f, 0xff, 0xe4, 0x0, 0x0, 0x5, + 0xef, 0xff, 0xd0, 0x0, 0x0, 0xcf, 0xff, 0xfd, + 0x98, 0xae, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa1, 0x0, + 0x0, 0x0, 0x0, 0x5c, 0xff, 0xff, 0xff, 0xfb, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x56, + 0x76, 0x41, 0x0, 0x0, 0x0, 0x0, + + /* U+0034 "4" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xfa, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0x95, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfd, 0x5, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xf3, 0x5, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0x80, 0x5, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfd, 0x0, 0x5, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xf3, 0x0, 0x5, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0x70, 0x0, 0x5, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfc, 0x0, 0x0, + 0x5, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf2, 0x0, 0x0, 0x5, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0x60, 0x0, 0x0, 0x5, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0xdf, 0xfb, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf5, 0x0, 0x0, 0x9, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf5, 0x0, + 0x0, 0x3f, 0xff, 0xa5, 0x55, 0x55, 0x55, 0x59, + 0xff, 0xf9, 0x55, 0x52, 0x6f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x6f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf5, + 0x0, 0x0, + + /* U+0035 "5" */ + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x1, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x4f, 0xff, 0xa7, 0x77, 0x77, 0x77, 0x77, + 0x77, 0x20, 0x0, 0x7, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x1, 0x8c, 0xef, 0xeb, + 0x71, 0x0, 0x0, 0x0, 0xb, 0xff, 0xd9, 0xff, + 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xd8, 0x54, 0x58, 0xef, + 0xff, 0xfa, 0x0, 0x4, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xf6, 0x0, 0x5d, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xe0, + 0x0, 0x0, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xb0, 0x0, 0x22, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf9, 0x1f, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x60, 0xef, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf2, 0xa, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xfb, 0x0, 0x4f, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, + 0x30, 0x0, 0xbf, 0xff, 0xf5, 0x0, 0x0, 0x4, + 0xef, 0xff, 0x90, 0x0, 0x1, 0xdf, 0xff, 0xfd, + 0x98, 0x9d, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x1, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x5c, 0xff, 0xff, 0xff, 0xfc, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x56, + 0x76, 0x51, 0x0, 0x0, 0x0, 0x0, + + /* U+0036 "6" */ + 0x0, 0x0, 0x0, 0x3, 0x8c, 0xef, 0xec, 0x82, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1a, 0xff, 0xff, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x2e, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x2e, 0xff, 0xfc, 0x51, 0x2, 0x7f, 0xff, + 0xfa, 0x0, 0x0, 0xc, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xf3, 0x0, 0x5, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x90, 0x0, + 0xcf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xfd, 0x0, 0x2f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xba, 0x80, 0x7, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xc0, 0x0, 0x0, 0x12, 0x20, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xfa, 0x0, 0x39, + 0xef, 0xff, 0xfc, 0x50, 0x0, 0x0, 0x1f, 0xff, + 0x80, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xc1, 0x0, + 0x2, 0xff, 0xf7, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe1, 0x0, 0x3f, 0xff, 0xdf, 0xff, 0x83, + 0x0, 0x38, 0xff, 0xff, 0xc0, 0x3, 0xff, 0xff, + 0xfe, 0x20, 0x0, 0x0, 0x3, 0xef, 0xff, 0x60, + 0x3f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xfe, 0x3, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf3, 0x2f, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x61, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf8, 0xf, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0x90, 0xcf, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf8, 0x9, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x60, 0x4f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf2, 0x0, 0xef, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xfd, 0x0, 0x7, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x60, 0x0, 0xd, 0xff, 0xfc, 0x20, 0x0, 0x1, + 0xbf, 0xff, 0xc0, 0x0, 0x0, 0x1d, 0xff, 0xff, + 0xb8, 0x8b, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, + 0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe2, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xcf, 0xff, 0xff, 0xfe, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x15, + 0x67, 0x63, 0x0, 0x0, 0x0, 0x0, + + /* U+0037 "7" */ + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf8, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x78, 0x88, + 0x88, 0x88, 0x88, 0x88, 0x88, 0xbf, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0038 "8" */ + 0x0, 0x0, 0x0, 0x28, 0xce, 0xfe, 0xd9, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xc2, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xe7, 0x20, 0x15, 0xdf, 0xff, + 0xf1, 0x0, 0x0, 0x4f, 0xff, 0xe2, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xa0, 0x0, 0xa, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x0, 0x0, + 0xef, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf3, 0x0, 0xf, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x50, 0x0, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xf4, 0x0, 0xc, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x10, 0x0, 0x6f, 0xff, 0xd1, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xa0, 0x0, 0x0, 0xcf, 0xff, 0xe6, + 0x10, 0x4, 0xbf, 0xff, 0xd1, 0x0, 0x0, 0x1, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa1, 0x0, + 0x0, 0x0, 0x0, 0x5e, 0xff, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x6e, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe4, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xd5, 0x10, 0x14, 0xbf, 0xff, 0xf6, 0x0, + 0x0, 0xbf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xf3, 0x0, 0x4f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xc0, 0xb, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x20, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf6, 0x2f, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0x83, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf8, 0x1f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x70, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xf5, 0xb, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x0, 0x4f, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x90, 0x0, 0xbf, 0xff, 0xf6, 0x0, 0x0, 0x2, + 0xbf, 0xff, 0xe1, 0x0, 0x0, 0xcf, 0xff, 0xfe, + 0xa8, 0x9c, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd2, 0x0, + 0x0, 0x0, 0x0, 0x4b, 0xff, 0xff, 0xff, 0xfd, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x46, + 0x77, 0x52, 0x0, 0x0, 0x0, 0x0, + + /* U+0039 "9" */ + 0x0, 0x0, 0x0, 0x49, 0xde, 0xfe, 0xb6, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x3, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xf7, 0x20, 0x15, 0xcf, 0xff, + 0xc0, 0x0, 0x0, 0xbf, 0xff, 0xe2, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0x80, 0x0, 0x3f, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x10, 0x9, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf7, 0x0, 0xdf, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xc0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x1, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xf3, 0x2f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0x51, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf7, 0xe, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x80, 0xbf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf9, 0x5, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0x90, 0xd, 0xff, + 0xfd, 0x20, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf9, + 0x0, 0x3f, 0xff, 0xff, 0x95, 0x34, 0x8e, 0xff, + 0xaf, 0xff, 0x80, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xa2, 0xff, 0xf7, 0x0, 0x0, 0x4d, + 0xff, 0xff, 0xff, 0xff, 0x70, 0x2f, 0xff, 0x60, + 0x0, 0x0, 0x6, 0xbe, 0xff, 0xc8, 0x10, 0x4, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xe0, 0x0, + 0x0, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xfa, 0x0, 0x7f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x50, 0x5, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xe0, 0x0, 0x1f, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf7, + 0x0, 0x0, 0x9f, 0xff, 0xb1, 0x0, 0x0, 0x1b, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfa, + 0x89, 0xbf, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x1, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x8e, 0xff, 0xff, 0xff, 0xc5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x67, + 0x65, 0x20, 0x0, 0x0, 0x0, 0x0, + + /* U+003A ":" */ + 0x4f, 0xff, 0xf4, 0xff, 0xff, 0x4f, 0xff, 0xf4, + 0xff, 0xff, 0x2, 0x22, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x22, 0x22, 0x4f, 0xff, 0xf4, + 0xff, 0xff, 0x4f, 0xff, 0xf4, 0xff, 0xff, + + /* U+003B ";" */ + 0x5f, 0xff, 0xd5, 0xff, 0xfd, 0x5f, 0xff, 0xd5, + 0xff, 0xfd, 0x2, 0x22, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x22, 0x22, 0x5f, 0xff, 0xd5, + 0xff, 0xfd, 0x5f, 0xff, 0xd5, 0xff, 0xfd, 0x0, + 0x4f, 0xc0, 0x6, 0xfb, 0x0, 0xcf, 0x70, 0x7f, + 0xf1, 0x5f, 0xf5, 0x0, 0xa3, 0x0, + + /* U+003C "<" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0x8e, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4b, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x17, 0xef, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x3, 0xaf, + 0xff, 0xff, 0xff, 0xa3, 0x0, 0x0, 0x0, 0x0, + 0x6c, 0xff, 0xff, 0xff, 0xd7, 0x10, 0x0, 0x0, + 0x0, 0x28, 0xef, 0xff, 0xff, 0xfa, 0x40, 0x0, + 0x0, 0x0, 0x4, 0xbf, 0xff, 0xff, 0xfd, 0x71, + 0x0, 0x0, 0x0, 0x0, 0x5e, 0xff, 0xff, 0xff, + 0xa4, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xe7, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xd3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xfd, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x18, 0xef, + 0xff, 0xff, 0xf9, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5c, 0xff, 0xff, 0xff, 0xc5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xaf, 0xff, + 0xff, 0xfe, 0x82, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x17, 0xef, 0xff, 0xff, 0xfb, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5b, 0xff, 0xff, + 0xff, 0xe8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x9f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xdf, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4b, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x10, + + /* U+003D "=" */ + 0x46, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, + 0x66, 0x66, 0x1a, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf3, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3a, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x66, + 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, + 0x61, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x3a, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x30, + + /* U+003E ">" */ + 0x63, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xfc, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xe8, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0xb4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xcf, 0xff, 0xff, 0xfd, 0x71, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3a, 0xff, + 0xff, 0xff, 0xf9, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x6d, 0xff, 0xff, 0xff, 0xc5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xaf, 0xff, + 0xff, 0xfe, 0x81, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x17, 0xdf, 0xff, 0xff, 0xfb, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4a, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0x9f, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6c, 0xff, 0xff, 0xff, 0xc5, + 0x0, 0x0, 0x0, 0x0, 0x28, 0xef, 0xff, 0xff, + 0xf9, 0x20, 0x0, 0x0, 0x0, 0x5, 0xbf, 0xff, + 0xff, 0xfd, 0x70, 0x0, 0x0, 0x0, 0x1, 0x8e, + 0xff, 0xff, 0xff, 0xb4, 0x0, 0x0, 0x0, 0x0, + 0x3b, 0xff, 0xff, 0xff, 0xe8, 0x20, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xfc, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xa3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xe8, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+003F "?" */ + 0x0, 0x0, 0x0, 0x1, 0x46, 0x76, 0x52, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4b, 0xff, 0xff, + 0xff, 0xfe, 0x70, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd3, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xfe, 0xa8, 0x9c, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x8f, 0xff, 0xf6, 0x0, 0x0, + 0x3, 0xdf, 0xff, 0xf1, 0x0, 0x1f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x90, 0x7, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x0, 0xcf, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf3, 0xf, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x40, 0x35, + 0x76, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xaa, 0xa3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x12, 0x22, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + + /* U+0040 "@" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x24, 0x67, 0x77, 0x65, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x27, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc7, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3b, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1a, 0xff, 0xff, 0xff, 0xda, 0x87, 0x78, 0x9b, + 0xef, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xef, 0xff, 0xfc, 0x61, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x7e, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xfc, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xcf, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x10, 0x0, 0x0, 0x6, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x4, 0xad, 0xfe, 0xc6, 0x0, + 0x5, 0xff, 0xf4, 0x0, 0xd, 0xff, 0x90, 0x0, + 0x0, 0xe, 0xff, 0x80, 0x0, 0x0, 0x1, 0xbf, + 0xff, 0xff, 0xff, 0xd2, 0x8, 0xff, 0xf1, 0x0, + 0x4, 0xff, 0xf1, 0x0, 0x0, 0x7f, 0xfd, 0x0, + 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x2b, 0xff, 0xd0, 0x0, 0x0, 0xcf, 0xf7, 0x0, + 0x0, 0xef, 0xf4, 0x0, 0x0, 0x2, 0xef, 0xff, + 0xc4, 0x10, 0x3b, 0xff, 0xde, 0xff, 0xa0, 0x0, + 0x0, 0x6f, 0xfb, 0x0, 0x5, 0xff, 0xd0, 0x0, + 0x0, 0xd, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x2f, 0xff, 0x0, + 0xa, 0xff, 0x60, 0x0, 0x0, 0x8f, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x30, 0x0, + 0x0, 0xf, 0xff, 0x10, 0xf, 0xff, 0x10, 0x0, + 0x2, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0x0, 0x0, 0x0, 0xd, 0xff, 0x20, + 0x2f, 0xfd, 0x0, 0x0, 0x9, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0xd, 0xff, 0x30, 0x5f, 0xfa, 0x0, 0x0, + 0xf, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0xe, 0xff, 0x10, + 0x7f, 0xf8, 0x0, 0x0, 0x5f, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0xf, 0xff, 0x0, 0x9f, 0xf7, 0x0, 0x0, + 0x9f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x3f, 0xfe, 0x0, + 0x9f, 0xf6, 0x0, 0x0, 0xaf, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x8f, 0xf9, 0x0, 0x9f, 0xf7, 0x0, 0x0, + 0xcf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0xef, 0xf5, 0x0, + 0x9f, 0xf8, 0x0, 0x0, 0xcf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x80, 0x0, 0x0, + 0x7, 0xff, 0xd0, 0x0, 0x7f, 0xfa, 0x0, 0x0, + 0xbf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x50, 0x0, 0x0, 0x1f, 0xff, 0x60, 0x0, + 0x5f, 0xfd, 0x0, 0x0, 0x8f, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x20, 0x0, 0x0, + 0xcf, 0xfd, 0x0, 0x0, 0x2f, 0xff, 0x10, 0x0, + 0x4f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0x0, 0x0, 0xb, 0xff, 0xf2, 0x0, 0x0, + 0xe, 0xff, 0x60, 0x0, 0xd, 0xff, 0xf6, 0x0, + 0x0, 0x2, 0xdf, 0xff, 0xfe, 0x0, 0x3, 0xdf, + 0xff, 0x50, 0x0, 0x0, 0x9, 0xff, 0xc0, 0x0, + 0x4, 0xff, 0xff, 0x82, 0x2, 0x8f, 0xfe, 0xff, + 0xff, 0xa6, 0xbf, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf4, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xff, 0xff, 0xe2, 0xef, 0xff, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfd, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xfb, 0x10, 0x8f, + 0xff, 0xff, 0xff, 0xc2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xa0, 0x0, 0x0, 0x3a, 0xef, + 0xea, 0x40, 0x0, 0x6, 0xdf, 0xfd, 0x93, 0x0, + 0x0, 0x5, 0x77, 0x70, 0x0, 0x8, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x90, + 0x0, 0x0, 0xbf, 0xff, 0xa1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xfc, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xfe, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xdf, 0xff, 0xc1, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfe, 0x72, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xcf, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xd9, 0x64, 0x21, 0x0, 0x1, + 0x35, 0x8b, 0xff, 0xff, 0xfe, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x19, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x81, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x17, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x71, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x58, + 0xbc, 0xef, 0xff, 0xfe, 0xda, 0x85, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0041 "A" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xdf, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0x4f, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xb, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xfb, 0x5, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf6, + 0x0, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf1, 0x0, + 0xaf, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xb0, 0x0, 0x4f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x50, 0x0, 0xe, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0x0, 0x0, 0x8, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xfa, 0x0, 0x0, 0x2, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x20, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xfd, 0x33, 0x33, 0x33, 0x33, + 0x37, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x8, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x70, 0x0, + 0x0, 0xe, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xd0, 0x0, 0x0, + 0x4f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xf4, 0x0, 0x0, 0xaf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfa, 0x0, 0x1, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0x10, 0x7, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0x70, 0xd, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xe0, + + /* U+0042 "B" */ + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xed, 0xb7, + 0x20, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xa1, 0x0, 0x0, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe2, 0x0, 0xe, 0xff, 0xf8, 0x88, 0x88, 0x88, + 0x8a, 0xcf, 0xff, 0xff, 0xe1, 0x0, 0xef, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x90, 0xe, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0x0, 0xef, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf3, + 0xe, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0x40, 0xef, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf4, 0xe, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x20, 0xef, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xe0, 0xe, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf6, 0x0, 0xef, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x13, 0x7d, 0xff, 0xfa, 0x0, 0xe, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x10, 0x0, 0xe, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, + 0xef, 0xff, 0x88, 0x88, 0x88, 0x88, 0x8a, 0xdf, + 0xff, 0xff, 0xb0, 0xe, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x18, 0xff, 0xff, 0x90, 0xef, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0x2e, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xf8, 0xef, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xbe, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xfc, 0xef, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xbe, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf9, 0xef, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x4e, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xd0, 0xef, 0xff, 0x88, 0x88, 0x88, + 0x88, 0x89, 0xcf, 0xff, 0xff, 0xf3, 0xe, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb2, 0x0, 0xe, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xed, 0xa7, 0x20, 0x0, + 0x0, + + /* U+0043 "C" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x56, 0x76, + 0x52, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xbf, 0xff, 0xff, 0xff, 0xfe, 0x81, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5d, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xfe, + 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xfe, 0x84, 0x0, 0x0, 0x16, 0xdf, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf7, + 0x0, 0x0, 0x6f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf1, 0x0, 0xe, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x90, 0x7, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xfe, 0x0, 0xdf, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xda, 0x60, 0x2f, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x24, 0x10, 0x1, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xc6, 0xb, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x60, 0x5f, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf1, 0x0, 0xef, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xfa, 0x0, 0x5, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x20, 0x0, + 0xb, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x1b, 0xff, 0xff, 0x70, 0x0, 0x0, 0x1d, 0xff, + 0xff, 0xe7, 0x20, 0x0, 0x3, 0x8f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x2d, 0xff, 0xff, 0xff, + 0xfe, 0xef, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x8e, 0xff, 0xff, 0xff, 0xff, 0xd7, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x46, 0x77, 0x65, 0x10, 0x0, 0x0, 0x0, 0x0, + + /* U+0044 "D" */ + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xca, + 0x62, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb2, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0xbf, + 0xff, 0xa8, 0x88, 0x88, 0x88, 0x9a, 0xdf, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0xbf, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x7f, 0xff, 0xff, 0x30, + 0x0, 0xbf, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xef, 0xff, 0xd0, 0x0, 0xbf, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf6, 0x0, 0xbf, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xfd, 0x0, + 0xbf, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0x30, 0xbf, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0x80, 0xbf, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xc0, 0xbf, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xe0, 0xbf, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf0, 0xbf, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf1, 0xbf, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf2, 0xbf, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf1, + 0xbf, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf1, 0xbf, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xf0, 0xbf, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xd0, 0xbf, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xb0, 0xbf, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x70, 0xbf, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0x20, 0xbf, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xfc, 0x0, 0xbf, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf4, 0x0, + 0xbf, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xef, 0xff, 0xb0, 0x0, 0xbf, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x8f, 0xff, 0xff, + 0x20, 0x0, 0xbf, 0xff, 0xa8, 0x88, 0x88, 0x88, + 0x9a, 0xdf, 0xff, 0xff, 0xf4, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x30, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x81, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0xb8, 0x40, 0x0, 0x0, 0x0, 0x0, + + /* U+0045 "E" */ + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x1a, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x1a, 0xff, 0xfa, 0x88, 0x88, 0x88, + 0x88, 0x88, 0x88, 0x88, 0x88, 0x80, 0xaf, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf0, 0xa, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, + 0xaf, 0xff, 0xa8, 0x88, 0x88, 0x88, 0x88, 0x88, + 0x88, 0x88, 0x70, 0xa, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xa8, 0x88, 0x88, + 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x6a, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xca, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfc, + + /* U+0046 "F" */ + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xaa, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xaa, + 0xff, 0xfa, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, + 0x88, 0x85, 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf7, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x70, 0xa, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0xaf, 0xff, 0xa8, 0x88, 0x88, 0x88, 0x88, 0x88, + 0x88, 0x30, 0xa, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+0047 "G" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x46, 0x77, + 0x65, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x39, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xa4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3c, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb2, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0xff, 0xff, 0xff, 0xfe, 0x30, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xb6, 0x20, 0x0, + 0x1, 0x5b, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xc3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4e, 0xff, 0xfd, 0x0, 0x0, 0x2f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, + 0xff, 0x60, 0x0, 0xbf, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xd0, + 0x3, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf3, 0xa, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xd4, 0xf, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x61, 0x0, 0x3f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xaf, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0x88, 0x88, 0x88, 0x88, 0xff, 0xff, + 0x5f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x1f, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xb, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0x4, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x0, 0xcf, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x0, 0x2f, + 0xff, 0xfd, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x19, 0xff, 0xff, 0x0, 0x5, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x18, 0xef, + 0xff, 0xff, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xea, + 0x53, 0x10, 0x13, 0x6b, 0xff, 0xff, 0xff, 0xe3, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0x10, 0x0, 0x0, + 0x0, 0x1a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x28, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xd8, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x46, 0x77, 0x76, 0x41, 0x0, 0x0, 0x0, 0x0, + + /* U+0048 "H" */ + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0xa8, 0x88, 0x88, 0x88, 0x88, 0x88, + 0x88, 0x88, 0xff, 0xff, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + + /* U+0049 "I" */ + 0x2f, 0xff, 0xd2, 0xff, 0xfd, 0x2f, 0xff, 0xd2, + 0xff, 0xfd, 0x2f, 0xff, 0xd2, 0xff, 0xfd, 0x2f, + 0xff, 0xd2, 0xff, 0xfd, 0x2f, 0xff, 0xd2, 0xff, + 0xfd, 0x2f, 0xff, 0xd2, 0xff, 0xfd, 0x2f, 0xff, + 0xd2, 0xff, 0xfd, 0x2f, 0xff, 0xd2, 0xff, 0xfd, + 0x2f, 0xff, 0xd2, 0xff, 0xfd, 0x2f, 0xff, 0xd2, + 0xff, 0xfd, 0x2f, 0xff, 0xd2, 0xff, 0xfd, 0x2f, + 0xff, 0xd2, 0xff, 0xfd, 0x2f, 0xff, 0xd2, 0xff, + 0xfd, 0x2f, 0xff, 0xd2, 0xff, 0xfd, 0x2f, 0xff, + 0xd2, 0xff, 0xfd, + + /* U+004A "J" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xb6, 0xac, 0xc0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xfa, 0xcf, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x9b, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf8, 0x8f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x44, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x4f, 0xff, 0xf1, 0xe, 0xff, 0xfd, + 0x51, 0x2, 0x7f, 0xff, 0xfa, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x20, 0x0, 0x7f, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0x40, 0x0, 0x0, + 0x4c, 0xff, 0xff, 0xff, 0xf9, 0x10, 0x0, 0x0, + 0x0, 0x1, 0x57, 0x76, 0x40, 0x0, 0x0, 0x0, + + /* U+004B "K" */ + 0xef, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xfc, 0x1e, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xfc, + 0x10, 0xef, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xfc, 0x0, 0xe, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xfb, + 0x0, 0x0, 0xef, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xfb, 0x0, 0x0, 0xe, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x10, 0x0, + 0x0, 0x8f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xf1, 0x0, 0x0, 0x8f, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x10, + 0x0, 0x8f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf1, 0x0, 0x8f, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x10, 0x8f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf1, 0x8f, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0x9f, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0xf5, + 0x8f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xf4, 0x0, 0xcf, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf4, + 0x0, 0x2, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xf4, 0x0, 0x0, 0x6, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0xef, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xfd, 0x10, 0x0, 0x0, 0xe, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xf6, 0x0, 0x0, 0xe, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf2, 0x0, 0x0, 0xef, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xd0, 0x0, + 0xe, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xa0, 0x0, 0xef, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0x50, 0xe, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0x20, 0xef, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xfd, 0xe, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf9, + + /* U+004C "L" */ + 0xdf, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x98, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, + 0x7d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, + + /* U+004D "M" */ + 0xdf, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xdd, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xfd, 0xdf, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xdd, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xfd, 0xdf, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0xdd, 0xff, 0xfa, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xfc, 0xff, 0xfd, 0xdf, + 0xff, 0x4f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0x7f, 0xff, 0xdd, 0xff, 0xf0, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xf1, 0xff, 0xfd, 0xdf, 0xff, 0xa, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfc, + 0xf, 0xff, 0xdd, 0xff, 0xf0, 0x4f, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x60, 0xff, + 0xfd, 0xdf, 0xff, 0x0, 0xef, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xf1, 0xf, 0xff, 0xdd, + 0xff, 0xf0, 0x9, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xfb, 0x0, 0xff, 0xfd, 0xdf, 0xff, + 0x0, 0x4f, 0xff, 0x50, 0x0, 0x0, 0x0, 0xd, + 0xff, 0x50, 0xf, 0xff, 0xdd, 0xff, 0xf0, 0x0, + 0xef, 0xfa, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf0, + 0x0, 0xff, 0xfd, 0xdf, 0xff, 0x0, 0x9, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x8f, 0xfa, 0x0, 0xf, + 0xff, 0xdd, 0xff, 0xf0, 0x0, 0x3f, 0xff, 0x50, + 0x0, 0x0, 0xd, 0xff, 0x50, 0x0, 0xff, 0xfd, + 0xdf, 0xff, 0x0, 0x0, 0xef, 0xfa, 0x0, 0x0, + 0x3, 0xff, 0xf0, 0x0, 0xf, 0xff, 0xdd, 0xff, + 0xf0, 0x0, 0x9, 0xff, 0xf0, 0x0, 0x0, 0x8f, + 0xfa, 0x0, 0x0, 0xff, 0xfd, 0xdf, 0xff, 0x0, + 0x0, 0x3f, 0xff, 0x50, 0x0, 0xe, 0xff, 0x40, + 0x0, 0xf, 0xff, 0xdd, 0xff, 0xf0, 0x0, 0x0, + 0xef, 0xfa, 0x0, 0x3, 0xff, 0xe0, 0x0, 0x0, + 0xff, 0xfd, 0xdf, 0xff, 0x0, 0x0, 0x8, 0xff, + 0xf0, 0x0, 0x9f, 0xf9, 0x0, 0x0, 0xf, 0xff, + 0xdd, 0xff, 0xf0, 0x0, 0x0, 0x3f, 0xff, 0x50, + 0xe, 0xff, 0x30, 0x0, 0x0, 0xff, 0xfd, 0xdf, + 0xff, 0x0, 0x0, 0x0, 0xdf, 0xfa, 0x4, 0xff, + 0xe0, 0x0, 0x0, 0xf, 0xff, 0xdd, 0xff, 0xf0, + 0x0, 0x0, 0x8, 0xff, 0xf0, 0x9f, 0xf8, 0x0, + 0x0, 0x0, 0xff, 0xfd, 0xdf, 0xff, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0x5e, 0xff, 0x30, 0x0, 0x0, + 0xf, 0xff, 0xdd, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0xdf, 0xfd, 0xff, 0xd0, 0x0, 0x0, 0x0, 0xff, + 0xfd, 0xdf, 0xff, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0xf, 0xff, 0xdd, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0xff, 0xfd, 0xdf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xdd, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xfd, + + /* U+004E "N" */ + 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xa, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xf0, 0xaf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xa, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xf0, 0xaf, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xa, 0xff, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xf0, 0xaf, 0xff, 0xef, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xa, + 0xff, 0xf4, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf0, 0xaf, 0xff, 0x27, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xa, 0xff, 0xf2, 0xc, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xf0, 0xaf, 0xff, 0x20, + 0x2f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xa, 0xff, 0xf2, 0x0, 0x7f, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf0, 0xaf, 0xff, + 0x20, 0x0, 0xcf, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xa, 0xff, 0xf2, 0x0, 0x2, 0xff, + 0xff, 0x70, 0x0, 0x0, 0xd, 0xff, 0xf0, 0xaf, + 0xff, 0x20, 0x0, 0x7, 0xff, 0xff, 0x20, 0x0, + 0x0, 0xdf, 0xff, 0xa, 0xff, 0xf2, 0x0, 0x0, + 0xc, 0xff, 0xfc, 0x0, 0x0, 0xd, 0xff, 0xf0, + 0xaf, 0xff, 0x20, 0x0, 0x0, 0x2f, 0xff, 0xf7, + 0x0, 0x0, 0xdf, 0xff, 0xa, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xf2, 0x0, 0xd, 0xff, + 0xf0, 0xaf, 0xff, 0x20, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xc0, 0x0, 0xdf, 0xff, 0xa, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x70, 0xd, + 0xff, 0xf0, 0xaf, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0x20, 0xdf, 0xff, 0xa, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, + 0xd, 0xff, 0xf0, 0xaf, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xf7, 0xdf, 0xff, 0xa, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xfe, 0xff, 0xf0, 0xaf, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, + 0xa, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0xf0, 0xaf, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xff, 0xa, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xf0, 0xaf, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xa, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf0, + + /* U+004F "O" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x36, 0x77, + 0x75, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xa3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xb2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xf9, 0x41, 0x0, 0x1, 0x6b, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfb, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x4d, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x5, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xcf, 0xff, 0xe1, + 0x0, 0x0, 0xe, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xfa, 0x0, + 0x0, 0x7f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x20, 0x0, + 0xef, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x90, 0x3, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xe0, 0x7, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf2, 0xb, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf6, 0xd, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xf8, 0xe, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf9, 0xf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfa, + 0xf, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfa, 0xf, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf9, 0xe, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xf8, 0xb, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf6, 0x8, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf2, 0x3, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xe0, 0x0, 0xef, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x90, 0x0, 0x7f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x20, + 0x0, 0xe, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xfa, 0x0, 0x0, + 0x6, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xcf, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xfa, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x3d, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xf8, 0x30, 0x0, 0x1, 0x5b, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xff, 0xee, 0xff, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xa3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x36, + 0x77, 0x75, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0050 "P" */ + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdc, + 0x96, 0x10, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0xcf, 0xff, 0x98, 0x88, + 0x88, 0x88, 0x88, 0xac, 0xff, 0xff, 0xf9, 0x0, + 0xcf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2c, 0xff, 0xff, 0x30, 0xcf, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xa0, + 0xcf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xe0, 0xcf, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf1, + 0xcf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf2, 0xcf, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf2, + 0xcf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf0, 0xcf, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xc0, + 0xcf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x70, 0xcf, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6e, 0xff, 0xff, 0x10, + 0xcf, 0xff, 0x98, 0x88, 0x88, 0x88, 0x89, 0xbf, + 0xff, 0xff, 0xf5, 0x0, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd4, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0xdb, 0x73, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0051 "Q" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x46, 0x77, + 0x65, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6c, 0xff, 0xff, 0xff, + 0xff, 0xf9, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xef, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xf9, 0x41, 0x0, 0x1, 0x5b, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xa1, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xdf, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xcf, 0xff, 0xf1, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xa0, 0x0, 0x0, 0x6f, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0x20, 0x0, 0xe, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xf9, 0x0, 0x3, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xe0, 0x0, 0x7f, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0x20, 0xb, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf6, 0x0, 0xdf, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0x80, 0xe, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfa, + 0x0, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xb0, + 0xf, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfb, 0x0, + 0xef, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xa0, 0xd, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf8, 0x0, 0xbf, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x60, 0x7, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf3, 0x0, 0x3f, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xfe, 0x0, 0x0, 0xdf, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x10, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x90, 0x0, 0x6, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xe8, 0x10, 0x0, + 0x3f, 0xff, 0xf3, 0x0, 0x0, 0xe, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x80, 0x1d, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xdc, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xfa, + 0x10, 0x0, 0x0, 0x5, 0xdf, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0x94, 0x0, 0x0, 0x16, 0xef, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xff, 0xee, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5e, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xc3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xcf, 0xff, + 0xff, 0xff, 0xfe, 0x93, 0x4, 0xef, 0xff, 0xfc, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x14, 0x67, + 0x76, 0x52, 0x0, 0x0, 0x1, 0x9f, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2a, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, + + /* U+0052 "R" */ + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xdb, 0x84, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x30, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, + 0xa, 0xff, 0xf8, 0x44, 0x44, 0x44, 0x44, 0x45, + 0x69, 0xef, 0xff, 0xfe, 0x10, 0x0, 0xaf, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xf8, 0x0, 0xa, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xe0, + 0x0, 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0x30, 0xa, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf5, 0x0, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x60, 0xa, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf4, 0x0, 0xaf, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x10, 0xa, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xc0, 0x0, 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xcf, 0xff, 0xf4, 0x0, 0xa, + 0xff, 0xf9, 0x66, 0x66, 0x66, 0x66, 0x67, 0xad, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb3, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xa6, 0x10, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf5, + 0x0, 0x0, 0x1, 0x5b, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0x80, 0x0, 0x0, 0xa, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0x30, 0x0, + 0x0, 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xfe, 0x0, 0x0, 0xa, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xf9, 0x0, 0x0, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf4, + 0x0, 0xa, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xd0, 0x0, 0xaf, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0x80, 0xa, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0x30, 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfd, 0xa, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xf8, + + /* U+0053 "S" */ + 0x0, 0x0, 0x0, 0x0, 0x2, 0x56, 0x77, 0x64, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xc6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x40, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x9, 0xff, 0xff, 0xc6, 0x20, + 0x0, 0x14, 0x9f, 0xff, 0xff, 0x40, 0x0, 0x3, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x1c, + 0xff, 0xfd, 0x0, 0x0, 0x9f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xf4, 0x0, + 0xd, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xa0, 0x0, 0xef, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfc, + 0x0, 0xe, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xa8, 0x60, 0x0, 0xcf, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0x91, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xfb, 0x61, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, + 0xfd, 0x95, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd8, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x27, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0x8c, 0xff, 0xff, 0xff, 0xfd, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x5a, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xcf, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x80, 0xac, + 0xda, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xfb, 0xf, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xc0, + 0xdf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xfb, 0x8, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x90, 0x2f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xf3, 0x0, 0x9f, 0xff, + 0xfb, 0x20, 0x0, 0x0, 0x0, 0x0, 0x2d, 0xff, + 0xfc, 0x0, 0x1, 0xdf, 0xff, 0xff, 0xb6, 0x21, + 0x1, 0x25, 0xaf, 0xff, 0xff, 0x20, 0x0, 0x1, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x28, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xb5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x14, 0x56, 0x77, 0x64, 0x0, 0x0, 0x0, 0x0, + + /* U+0054 "T" */ + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb1, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfb, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x88, 0x88, + 0x88, 0x88, 0x89, 0xff, 0xfe, 0x88, 0x88, 0x88, + 0x88, 0x85, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0055 "U" */ + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0x9f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0x8f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfe, + 0x7f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xfc, 0x4f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfb, + 0x1f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf8, 0xe, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf4, + 0x8, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xe0, 0x2, 0xff, 0xff, 0xc1, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x70, + 0x0, 0x8f, 0xff, 0xff, 0xa5, 0x21, 0x12, 0x48, + 0xef, 0xff, 0xfd, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x10, 0x0, 0x0, 0x0, 0x2, 0x9e, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x25, 0x67, 0x76, 0x53, + 0x0, 0x0, 0x0, 0x0, + + /* U+0056 "V" */ + 0x9f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xf8, 0x3f, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf1, 0xd, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xb0, 0x7, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x50, + 0x1, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xfe, 0x0, 0x0, 0xaf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xf8, 0x0, 0x0, 0x4f, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf2, 0x0, 0x0, 0xe, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xc0, 0x0, + 0x0, 0x7, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x50, 0x0, 0x0, 0x1, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x10, + 0x0, 0x0, 0x2, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x60, 0x0, 0x0, + 0x8, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xc0, 0x0, 0x0, 0xd, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xf2, 0x0, 0x0, 0x3f, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf8, + 0x0, 0x0, 0x9f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfd, 0x0, 0x0, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x30, 0x5, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x90, 0xb, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xe0, 0xf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf3, 0x5f, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xf8, 0xbf, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xfd, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0057 "W" */ + 0x6f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf0, 0x2f, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xa0, + 0xe, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0x60, 0xa, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x20, + 0x5, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xf9, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xfd, 0x0, 0x1, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xf4, 0xcf, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf9, 0x0, + 0x0, 0xdf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf0, 0x8f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xf4, 0x0, 0x0, 0x9f, 0xff, 0x40, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xb0, 0x3f, 0xff, + 0x50, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf0, 0x0, + 0x0, 0x4f, 0xff, 0x70, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x70, 0xe, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xc0, 0x0, 0x0, 0xf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x20, 0xa, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x70, 0x0, + 0x0, 0xc, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x8f, + 0xfe, 0x0, 0x6, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x30, 0x0, 0x0, 0x8, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0xdf, 0xfa, 0x0, 0x1, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0xbf, 0xfe, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf6, 0x0, 0x0, 0x1, 0xff, + 0xf5, 0x0, 0x0, 0xdf, 0xfc, 0x0, 0x0, 0x0, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfa, + 0x0, 0x0, 0x6, 0xff, 0xf1, 0x0, 0x0, 0x9f, + 0xff, 0x10, 0x0, 0x3, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xfe, 0x0, 0x0, 0xa, 0xff, + 0xc0, 0x0, 0x0, 0x4f, 0xff, 0x50, 0x0, 0x7, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0x10, 0x0, 0xe, 0xff, 0x80, 0x0, 0x0, 0xf, + 0xff, 0x90, 0x0, 0xb, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x50, 0x0, 0x3f, 0xff, + 0x30, 0x0, 0x0, 0xb, 0xff, 0xd0, 0x0, 0xe, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0x90, 0x0, 0x8f, 0xff, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xf1, 0x0, 0x3f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xc0, 0x0, 0xcf, 0xfa, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf5, 0x0, 0x6f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xf0, 0x1, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xf9, 0x0, 0xaf, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xf4, 0x5, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfd, 0x0, 0xef, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xf7, 0x9, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x12, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xfb, 0xd, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x46, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xfe, 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0x7a, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x6f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xad, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xdf, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xdf, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + + /* U+0058 "X" */ + 0x2, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0x80, 0x0, 0x5f, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xfc, 0x0, 0x0, 0xa, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0xef, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xd0, 0x0, 0x0, 0x5, 0xff, 0xfe, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf9, + 0x0, 0x0, 0x2f, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x50, 0x0, + 0xdf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xe1, 0x9, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xfa, 0x4f, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xef, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xfd, 0xdf, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xf3, 0x4f, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0x80, 0x9, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xfc, 0x0, 0x0, + 0xdf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xf2, 0x0, 0x0, 0x3f, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x7, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x3f, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xf3, 0x0, 0x1, 0xef, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfe, 0x10, + 0xb, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xa0, 0x7f, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf6, + + /* U+0059 "Y" */ + 0x8f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf5, 0xd, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xa0, 0x3, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xfe, 0x10, 0x0, 0x8f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf4, 0x0, + 0x0, 0xd, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x90, 0x0, 0x0, 0x3, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x8, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf3, 0x0, 0x0, 0x3f, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xfc, 0x0, 0x0, 0xdf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x60, 0x7, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xe1, 0x1f, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xf9, 0xaf, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+005A "Z" */ + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x4, 0x88, + 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xdf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfc, + 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, + 0x88, 0x43, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x83, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + + /* U+005B "[" */ + 0x3f, 0xff, 0xff, 0xff, 0xf3, 0xff, 0xff, 0xff, + 0xff, 0x3f, 0xff, 0xff, 0xff, 0xf3, 0xff, 0xf7, + 0x0, 0x0, 0x3f, 0xff, 0x70, 0x0, 0x3, 0xff, + 0xf7, 0x0, 0x0, 0x3f, 0xff, 0x70, 0x0, 0x3, + 0xff, 0xf7, 0x0, 0x0, 0x3f, 0xff, 0x70, 0x0, + 0x3, 0xff, 0xf7, 0x0, 0x0, 0x3f, 0xff, 0x70, + 0x0, 0x3, 0xff, 0xf7, 0x0, 0x0, 0x3f, 0xff, + 0x70, 0x0, 0x3, 0xff, 0xf7, 0x0, 0x0, 0x3f, + 0xff, 0x70, 0x0, 0x3, 0xff, 0xf7, 0x0, 0x0, + 0x3f, 0xff, 0x70, 0x0, 0x3, 0xff, 0xf7, 0x0, + 0x0, 0x3f, 0xff, 0x70, 0x0, 0x3, 0xff, 0xf7, + 0x0, 0x0, 0x3f, 0xff, 0x70, 0x0, 0x3, 0xff, + 0xf7, 0x0, 0x0, 0x3f, 0xff, 0x70, 0x0, 0x3, + 0xff, 0xf7, 0x0, 0x0, 0x3f, 0xff, 0x70, 0x0, + 0x3, 0xff, 0xf7, 0x0, 0x0, 0x3f, 0xff, 0x70, + 0x0, 0x3, 0xff, 0xf7, 0x0, 0x0, 0x3f, 0xff, + 0x70, 0x0, 0x3, 0xff, 0xf7, 0x0, 0x0, 0x3f, + 0xff, 0x70, 0x0, 0x3, 0xff, 0xf7, 0x0, 0x0, + 0x3f, 0xff, 0x70, 0x0, 0x3, 0xff, 0xf7, 0x0, + 0x0, 0x3f, 0xff, 0x70, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xf3, 0xff, + 0xff, 0xff, 0xff, + + /* U+005C "\\" */ + 0x78, 0x70, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x10, 0x0, 0x0, 0x0, 0x9, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x4, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x9, 0xff, 0x60, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x9, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0x10, 0x0, 0x0, 0x0, 0x9, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x4, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xf8, + + /* U+005D "]" */ + 0x4f, 0xff, 0xff, 0xff, 0xe4, 0xff, 0xff, 0xff, + 0xfe, 0x4f, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0xdf, 0xfe, 0x0, 0x0, 0xd, 0xff, 0xe0, 0x0, + 0x0, 0xdf, 0xfe, 0x0, 0x0, 0xd, 0xff, 0xe0, + 0x0, 0x0, 0xdf, 0xfe, 0x0, 0x0, 0xd, 0xff, + 0xe0, 0x0, 0x0, 0xdf, 0xfe, 0x0, 0x0, 0xd, + 0xff, 0xe0, 0x0, 0x0, 0xdf, 0xfe, 0x0, 0x0, + 0xd, 0xff, 0xe0, 0x0, 0x0, 0xdf, 0xfe, 0x0, + 0x0, 0xd, 0xff, 0xe0, 0x0, 0x0, 0xdf, 0xfe, + 0x0, 0x0, 0xd, 0xff, 0xe0, 0x0, 0x0, 0xdf, + 0xfe, 0x0, 0x0, 0xd, 0xff, 0xe0, 0x0, 0x0, + 0xdf, 0xfe, 0x0, 0x0, 0xd, 0xff, 0xe0, 0x0, + 0x0, 0xdf, 0xfe, 0x0, 0x0, 0xd, 0xff, 0xe0, + 0x0, 0x0, 0xdf, 0xfe, 0x0, 0x0, 0xd, 0xff, + 0xe0, 0x0, 0x0, 0xdf, 0xfe, 0x0, 0x0, 0xd, + 0xff, 0xe0, 0x0, 0x0, 0xdf, 0xfe, 0x0, 0x0, + 0xd, 0xff, 0xe0, 0x0, 0x0, 0xdf, 0xfe, 0x0, + 0x0, 0xd, 0xff, 0xe0, 0x0, 0x0, 0xdf, 0xfe, + 0x0, 0x0, 0xd, 0xff, 0xe0, 0x0, 0x0, 0xdf, + 0xfe, 0x0, 0x0, 0xd, 0xff, 0xe4, 0xff, 0xff, + 0xff, 0xfe, 0x4f, 0xff, 0xff, 0xff, 0xe4, 0xff, + 0xff, 0xff, 0xfe, + + /* U+005E "^" */ + 0x0, 0x0, 0x0, 0xd, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xbf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0x39, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xfd, 0x2, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xf6, 0x0, 0xbf, 0xfb, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xf0, 0x0, 0x4f, 0xff, 0x30, + 0x0, 0x0, 0xe, 0xff, 0x90, 0x0, 0xd, 0xff, + 0xa0, 0x0, 0x0, 0x6f, 0xff, 0x20, 0x0, 0x7, + 0xff, 0xf1, 0x0, 0x0, 0xdf, 0xfc, 0x0, 0x0, + 0x1, 0xff, 0xf8, 0x0, 0x4, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x0, 0xc, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x70, 0x3f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0xb, 0xff, 0xe0, 0xaf, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf5, + + /* U+005F "_" */ + 0x2a, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0x64, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, + + /* U+0060 "`" */ + 0x9, 0xbb, 0xba, 0x0, 0x0, 0x3f, 0xff, 0xf5, + 0x0, 0x0, 0x5f, 0xff, 0xd0, 0x0, 0x0, 0x8f, + 0xff, 0x50, 0x0, 0x0, 0xaf, 0xfc, 0x0, 0x0, + 0x0, 0xcf, 0xf4, + + /* U+0061 "a" */ + 0x0, 0x0, 0x1, 0x6a, 0xde, 0xff, 0xed, 0xa5, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x40, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x9, 0xff, 0xfe, 0x73, 0x10, 0x13, 0x7e, 0xff, + 0xfe, 0x0, 0x2, 0xff, 0xfe, 0x20, 0x0, 0x0, + 0x0, 0x2e, 0xff, 0xf3, 0x0, 0x7f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x50, 0x6, + 0xac, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0x7c, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x1, 0x57, 0xac, 0xef, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x1, 0x7d, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf7, 0x0, 0x4, 0xef, 0xff, 0xff, + 0xff, 0xfd, 0x95, 0x5f, 0xff, 0x70, 0x4, 0xff, + 0xff, 0xfb, 0x85, 0x20, 0x0, 0x4, 0xff, 0xf7, + 0x0, 0xdf, 0xff, 0xa1, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x70, 0x3f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf7, 0x5, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x80, + 0x5f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf8, 0x3, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x4e, 0xff, 0xff, 0x80, 0xd, 0xff, 0xfe, + 0x60, 0x0, 0x4, 0xaf, 0xff, 0xff, 0xf9, 0x0, + 0x3f, 0xff, 0xff, 0xfe, 0xef, 0xff, 0xff, 0xce, + 0xff, 0xb0, 0x0, 0x4e, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x70, 0xbf, 0xff, 0x0, 0x0, 0x6, 0xbe, + 0xff, 0xec, 0x95, 0x0, 0x6, 0xff, 0xf6, + + /* U+0062 "b" */ + 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x80, 0x6, 0xbe, 0xfe, 0xc7, 0x20, + 0x0, 0x0, 0x2f, 0xff, 0x82, 0xdf, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x2f, 0xff, 0xae, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x2f, 0xff, + 0xff, 0xfb, 0x41, 0x2, 0x8f, 0xff, 0xf9, 0x0, + 0x2f, 0xff, 0xff, 0x70, 0x0, 0x0, 0x3, 0xff, + 0xff, 0x30, 0x2f, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xb0, 0x2f, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf1, 0x2f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf5, + 0x2f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf8, 0x2f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xfa, 0x2f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xfb, 0x2f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfa, + 0x2f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf9, 0x2f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf7, 0x2f, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xf3, 0x2f, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf0, + 0x2f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x90, 0x2f, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x5, 0xff, 0xff, 0x10, 0x2f, 0xff, 0xff, 0xfa, + 0x31, 0x3, 0x9f, 0xff, 0xf5, 0x0, 0x2f, 0xff, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x2f, 0xff, 0x43, 0xef, 0xff, 0xff, 0xff, 0xe4, + 0x0, 0x0, 0x2f, 0xff, 0x40, 0x7, 0xce, 0xfe, + 0xb6, 0x0, 0x0, 0x0, + + /* U+0063 "c" */ + 0x0, 0x0, 0x0, 0x48, 0xce, 0xfe, 0xd9, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x2c, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x20, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x2f, + 0xff, 0xfd, 0x61, 0x1, 0x4c, 0xff, 0xfe, 0x10, + 0x0, 0xdf, 0xff, 0x90, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0x80, 0x5, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xe0, 0xb, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xd2, 0xf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x10, 0x0, + 0x2f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x20, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xe6, 0xb, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf5, + 0x4, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xf0, 0x0, 0xdf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0x80, 0x0, 0x2f, 0xff, 0xfb, + 0x41, 0x1, 0x5c, 0xff, 0xfd, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0x3c, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x49, 0xce, 0xff, + 0xc8, 0x20, 0x0, 0x0, + + /* U+0064 "d" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf6, + 0x0, 0x0, 0x1, 0x6b, 0xef, 0xec, 0x71, 0x4, + 0xff, 0xf6, 0x0, 0x0, 0x5e, 0xff, 0xff, 0xff, + 0xfe, 0x54, 0xff, 0xf6, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0xff, 0xf6, 0x0, 0x5f, + 0xff, 0xfa, 0x41, 0x13, 0x8f, 0xff, 0xff, 0xf6, + 0x1, 0xef, 0xff, 0x60, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xf6, 0x7, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xf6, 0xd, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf6, 0x1f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf6, + 0x4f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf6, 0x6f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xf6, 0x7f, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf6, 0x7f, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf6, + 0x6f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf6, 0x4f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xf6, 0xf, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf6, 0xc, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf6, + 0x5, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf6, 0x0, 0xdf, 0xff, 0x80, 0x0, 0x0, + 0x3, 0xef, 0xff, 0xf6, 0x0, 0x3f, 0xff, 0xfb, + 0x41, 0x2, 0x8f, 0xff, 0xff, 0xf6, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0xff, 0xf6, + 0x0, 0x0, 0x3d, 0xff, 0xff, 0xff, 0xff, 0x60, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x5a, 0xdf, 0xfd, + 0x82, 0x0, 0xff, 0xf6, + + /* U+0065 "e" */ + 0x0, 0x0, 0x0, 0x28, 0xce, 0xfe, 0xda, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xd4, 0x0, 0x0, 0x0, 0x2, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xe6, 0x20, 0x3, 0xaf, 0xff, + 0xf5, 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x3e, 0xff, 0xf1, 0x0, 0x3f, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x90, 0xa, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x0, 0xef, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf4, 0x2f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x74, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xa5, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x4f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x12, 0x0, 0x0, 0xbf, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xe5, + 0x5, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0x20, 0xc, 0xff, 0xfc, 0x10, 0x0, + 0x0, 0x1, 0xdf, 0xff, 0x90, 0x0, 0x2f, 0xff, + 0xfe, 0x72, 0x0, 0x27, 0xef, 0xff, 0xd1, 0x0, + 0x0, 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd2, 0x0, 0x0, 0x0, 0x2b, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xa1, 0x0, 0x0, 0x0, 0x0, 0x3, + 0x8c, 0xef, 0xfe, 0xc8, 0x20, 0x0, 0x0, + + /* U+0066 "f" */ + 0x0, 0x0, 0x0, 0x3, 0x67, 0x75, 0x30, 0x0, + 0x0, 0x5, 0xef, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0xef, + 0xff, 0xfe, 0xdf, 0x90, 0x0, 0x3, 0xff, 0xfe, + 0x30, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xf4, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x8d, 0xde, 0xff, + 0xfd, 0xdd, 0xd6, 0x0, 0x0, 0x6, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf4, 0x0, 0x0, + 0x0, + + /* U+0067 "g" */ + 0x0, 0x0, 0x0, 0x6b, 0xdf, 0xed, 0x82, 0x0, + 0xcf, 0xfa, 0x0, 0x0, 0x5e, 0xff, 0xff, 0xff, + 0xff, 0x80, 0xcf, 0xfa, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0xcf, 0xfa, 0x0, 0x4f, + 0xff, 0xfb, 0x41, 0x3, 0x8f, 0xff, 0xff, 0xfa, + 0x0, 0xef, 0xff, 0x70, 0x0, 0x0, 0x2, 0xef, + 0xff, 0xfa, 0x7, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xfa, 0xd, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xfa, 0x1f, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfa, + 0x5f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xfa, 0x7f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xfa, 0x8f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfa, 0x8f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfa, + 0x7f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xfa, 0x5f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xfa, 0x2f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xfa, 0xd, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfa, + 0x7, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xfa, 0x0, 0xef, 0xff, 0x70, 0x0, 0x0, + 0x2, 0xef, 0xff, 0xfa, 0x0, 0x4f, 0xff, 0xfb, + 0x41, 0x2, 0x8f, 0xff, 0xff, 0xf9, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0xff, 0xf9, + 0x0, 0x0, 0x5e, 0xff, 0xff, 0xff, 0xff, 0x72, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x6b, 0xdf, 0xfd, + 0x82, 0x3, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf5, 0x4, 0x42, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf3, + 0xc, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xe0, 0x8, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0x80, 0x2, 0xff, 0xff, 0x94, + 0x10, 0x2, 0x6d, 0xff, 0xfe, 0x10, 0x0, 0x7f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe2, 0x0, + 0x0, 0x5, 0xef, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x10, 0x0, 0x0, 0x0, 0x5, 0xad, 0xef, 0xfe, + 0xb7, 0x20, 0x0, 0x0, + + /* U+0068 "h" */ + 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x80, 0x4, + 0x9d, 0xff, 0xeb, 0x60, 0x0, 0x2, 0xff, 0xf8, + 0x1b, 0xff, 0xff, 0xff, 0xff, 0xe3, 0x0, 0x2f, + 0xff, 0xae, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + 0x2, 0xff, 0xff, 0xff, 0xd7, 0x32, 0x49, 0xff, + 0xff, 0xa0, 0x2f, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x4, 0xff, 0xff, 0x12, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xf4, 0x2f, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x72, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf8, + 0x2f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0x82, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf9, 0x2f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x92, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf9, 0x2f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x92, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xf9, 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x92, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xf9, 0x2f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x92, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf9, 0x2f, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x92, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf9, 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0x92, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xf9, + + /* U+0069 "i" */ + 0x3f, 0xff, 0x83, 0xff, 0xf8, 0x3f, 0xff, 0x83, + 0xff, 0xf8, 0x3, 0x33, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x83, 0xff, + 0xf8, 0x3f, 0xff, 0x83, 0xff, 0xf8, 0x3f, 0xff, + 0x83, 0xff, 0xf8, 0x3f, 0xff, 0x83, 0xff, 0xf8, + 0x3f, 0xff, 0x83, 0xff, 0xf8, 0x3f, 0xff, 0x83, + 0xff, 0xf8, 0x3f, 0xff, 0x83, 0xff, 0xf8, 0x3f, + 0xff, 0x83, 0xff, 0xf8, 0x3f, 0xff, 0x83, 0xff, + 0xf8, 0x3f, 0xff, 0x83, 0xff, 0xf8, 0x3f, 0xff, + 0x83, 0xff, 0xf8, + + /* U+006A "j" */ + 0x0, 0x0, 0x2f, 0xff, 0x80, 0x0, 0x2, 0xff, + 0xf8, 0x0, 0x0, 0x2f, 0xff, 0x80, 0x0, 0x2, + 0xff, 0xf8, 0x0, 0x0, 0x3, 0x33, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x80, 0x0, 0x2, 0xff, 0xf8, 0x0, 0x0, 0x2f, + 0xff, 0x80, 0x0, 0x2, 0xff, 0xf8, 0x0, 0x0, + 0x2f, 0xff, 0x80, 0x0, 0x2, 0xff, 0xf8, 0x0, + 0x0, 0x2f, 0xff, 0x80, 0x0, 0x2, 0xff, 0xf8, + 0x0, 0x0, 0x2f, 0xff, 0x80, 0x0, 0x2, 0xff, + 0xf8, 0x0, 0x0, 0x2f, 0xff, 0x80, 0x0, 0x2, + 0xff, 0xf8, 0x0, 0x0, 0x2f, 0xff, 0x80, 0x0, + 0x2, 0xff, 0xf8, 0x0, 0x0, 0x2f, 0xff, 0x80, + 0x0, 0x2, 0xff, 0xf8, 0x0, 0x0, 0x2f, 0xff, + 0x80, 0x0, 0x2, 0xff, 0xf8, 0x0, 0x0, 0x2f, + 0xff, 0x80, 0x0, 0x2, 0xff, 0xf8, 0x0, 0x0, + 0x2f, 0xff, 0x80, 0x0, 0x2, 0xff, 0xf8, 0x0, + 0x0, 0x2f, 0xff, 0x80, 0x0, 0x3, 0xff, 0xf7, + 0x0, 0x0, 0x4f, 0xff, 0x60, 0x0, 0x7, 0xff, + 0xf4, 0x15, 0x36, 0xff, 0xff, 0x6, 0xff, 0xff, + 0xff, 0xa0, 0x9f, 0xff, 0xff, 0xe2, 0x8, 0xef, + 0xfd, 0x91, 0x0, + + /* U+006B "k" */ + 0x3f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xf7, 0x3, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf7, 0x0, 0x3f, + 0xff, 0x70, 0x0, 0x0, 0x4f, 0xff, 0xf7, 0x0, + 0x3, 0xff, 0xf7, 0x0, 0x0, 0x3f, 0xff, 0xf6, + 0x0, 0x0, 0x3f, 0xff, 0x70, 0x0, 0x3f, 0xff, + 0xf6, 0x0, 0x0, 0x3, 0xff, 0xf7, 0x0, 0x3f, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x70, + 0x3e, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf7, 0x2e, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xae, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf5, + 0x7f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf4, 0x0, 0xcf, 0xff, 0x80, 0x0, 0x0, 0x3, + 0xff, 0xf8, 0x0, 0x2, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x3f, 0xff, 0x70, 0x0, 0x8, 0xff, 0xfd, + 0x0, 0x0, 0x3, 0xff, 0xf7, 0x0, 0x0, 0xd, + 0xff, 0xf8, 0x0, 0x0, 0x3f, 0xff, 0x70, 0x0, + 0x0, 0x3f, 0xff, 0xf3, 0x0, 0x3, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xd0, 0x0, 0x3f, + 0xff, 0x70, 0x0, 0x0, 0x0, 0xef, 0xff, 0x80, + 0x3, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0x30, 0x3f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xfd, 0x3, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xf8, + + /* U+006C "l" */ + 0x3f, 0xff, 0x73, 0xff, 0xf7, 0x3f, 0xff, 0x73, + 0xff, 0xf7, 0x3f, 0xff, 0x73, 0xff, 0xf7, 0x3f, + 0xff, 0x73, 0xff, 0xf7, 0x3f, 0xff, 0x73, 0xff, + 0xf7, 0x3f, 0xff, 0x73, 0xff, 0xf7, 0x3f, 0xff, + 0x73, 0xff, 0xf7, 0x3f, 0xff, 0x73, 0xff, 0xf7, + 0x3f, 0xff, 0x73, 0xff, 0xf7, 0x3f, 0xff, 0x73, + 0xff, 0xf7, 0x3f, 0xff, 0x73, 0xff, 0xf7, 0x3f, + 0xff, 0x73, 0xff, 0xf7, 0x3f, 0xff, 0x73, 0xff, + 0xf7, 0x3f, 0xff, 0x73, 0xff, 0xf7, 0x3f, 0xff, + 0x73, 0xff, 0xf7, + + /* U+006D "m" */ + 0x4f, 0xff, 0x0, 0x5, 0xbd, 0xfe, 0xc8, 0x10, + 0x0, 0x0, 0x5b, 0xef, 0xec, 0x81, 0x0, 0x4, + 0xff, 0xf0, 0x2d, 0xff, 0xff, 0xff, 0xff, 0x40, + 0x2, 0xdf, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x4f, + 0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x23, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x4, 0xff, + 0xfe, 0xff, 0xb5, 0x33, 0x8f, 0xff, 0xfb, 0xef, + 0xf9, 0x42, 0x37, 0xff, 0xff, 0x90, 0x4f, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xe3, + 0x0, 0x0, 0x4, 0xff, 0xfe, 0x4, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf2, 0x4f, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x34, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf4, 0x4f, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0x44, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xf4, 0x4f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x44, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf4, 0x4f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x44, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xf4, 0x4f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x44, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf4, + 0x4f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x44, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf4, 0x4f, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x44, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf4, 0x4f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x44, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xf4, + + /* U+006E "n" */ + 0x2f, 0xff, 0x20, 0x4, 0x9d, 0xef, 0xeb, 0x60, + 0x0, 0x2, 0xff, 0xf2, 0x1b, 0xff, 0xff, 0xff, + 0xff, 0xd3, 0x0, 0x2f, 0xff, 0x3d, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf2, 0x2, 0xff, 0xfd, 0xff, + 0xc6, 0x32, 0x49, 0xff, 0xff, 0xb0, 0x2f, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x4, 0xff, 0xff, 0x12, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf5, 0x2f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x72, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf8, 0x2f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x82, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf8, 0x2f, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x82, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf8, 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0x82, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xf8, 0x2f, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x82, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf8, + 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0x82, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf8, 0x2f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x82, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf8, 0x2f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x82, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xf8, + + /* U+006F "o" */ + 0x0, 0x0, 0x0, 0x38, 0xce, 0xfe, 0xda, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xe6, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xd6, 0x20, 0x14, 0xaf, 0xff, + 0xf8, 0x0, 0x0, 0xef, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf4, 0x0, 0x7f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xc0, 0xd, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x31, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xf7, 0x5f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xb6, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xfc, 0x7f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xd7, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xfd, 0x6f, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xc5, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xfa, 0x1f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x60, 0xdf, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf3, + 0x7, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xfc, 0x0, 0xe, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0x40, 0x0, 0x4f, 0xff, + 0xfd, 0x61, 0x1, 0x4a, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x2b, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x60, 0x0, 0x0, 0x0, 0x0, 0x3, + 0x8c, 0xef, 0xfd, 0xa5, 0x0, 0x0, 0x0, + + /* U+0070 "p" */ + 0x2f, 0xff, 0x30, 0x6, 0xbe, 0xfe, 0xc8, 0x20, + 0x0, 0x0, 0x2f, 0xff, 0x33, 0xdf, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x2f, 0xff, 0x6f, 0xff, + 0xfe, 0xef, 0xff, 0xff, 0xb0, 0x0, 0x2f, 0xff, + 0xff, 0xfa, 0x20, 0x0, 0x6e, 0xff, 0xf9, 0x0, + 0x2f, 0xff, 0xff, 0x70, 0x0, 0x0, 0x2, 0xef, + 0xff, 0x40, 0x2f, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xb0, 0x2f, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf2, 0x2f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf6, + 0x2f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf9, 0x2f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xfa, 0x2f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xfb, 0x2f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfb, + 0x2f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xfa, 0x2f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf8, 0x2f, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf4, 0x2f, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf0, + 0x2f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x90, 0x2f, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x5, 0xff, 0xff, 0x20, 0x2f, 0xff, 0xff, 0xf9, + 0x30, 0x3, 0xaf, 0xff, 0xf6, 0x0, 0x2f, 0xff, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x2f, 0xff, 0x84, 0xef, 0xff, 0xff, 0xff, 0xe5, + 0x0, 0x0, 0x2f, 0xff, 0x80, 0x7, 0xce, 0xfe, + 0xb6, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0071 "q" */ + 0x0, 0x0, 0x0, 0x6b, 0xef, 0xec, 0x71, 0x0, + 0xef, 0xf6, 0x0, 0x0, 0x5e, 0xff, 0xff, 0xff, + 0xff, 0x50, 0xef, 0xf6, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xef, 0xff, 0xf6, 0xef, 0xf6, 0x0, 0x4f, + 0xff, 0xf9, 0x20, 0x1, 0x7f, 0xff, 0xff, 0xf6, + 0x0, 0xef, 0xff, 0x50, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xf6, 0x6, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf6, 0xd, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf6, 0x1f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf6, + 0x4f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf6, 0x5f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf6, 0x6f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xf6, 0x6f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf6, + 0x5f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xf6, 0x2f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xf6, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf6, 0xa, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf6, + 0x3, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf6, 0x0, 0xbf, 0xff, 0x90, 0x0, 0x0, + 0x2, 0xef, 0xff, 0xf6, 0x0, 0x1e, 0xff, 0xfc, + 0x51, 0x2, 0x8f, 0xff, 0xff, 0xf6, 0x0, 0x3, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xf6, + 0x0, 0x0, 0x2c, 0xff, 0xff, 0xff, 0xff, 0x74, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x4a, 0xdf, 0xfd, + 0x81, 0x4, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf6, + + /* U+0072 "r" */ + 0x4f, 0xff, 0x0, 0x3b, 0xfe, 0xc8, 0x24, 0xff, + 0xf0, 0x5f, 0xff, 0xff, 0xf5, 0x4f, 0xff, 0x3f, + 0xff, 0xff, 0xff, 0x4, 0xff, 0xfd, 0xff, 0xec, + 0xef, 0xa0, 0x4f, 0xff, 0xff, 0x60, 0x0, 0x33, + 0x4, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + + /* U+0073 "s" */ + 0x0, 0x0, 0x28, 0xce, 0xff, 0xec, 0x83, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x20, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x7f, 0xff, 0xd6, + 0x21, 0x2, 0x6d, 0xff, 0xfc, 0x0, 0xd, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xf3, 0x0, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x70, 0xf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x53, 0x10, 0x0, 0xdf, 0xff, 0x91, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xfc, + 0x73, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xff, 0xa6, 0x10, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc4, 0x0, + 0x0, 0x0, 0x1, 0x6b, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x48, 0xcf, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xcf, 0xff, 0xf1, 0x0, 0x24, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x48, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf5, + 0x5f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x30, 0xef, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xe0, 0x6, 0xff, 0xff, 0x93, 0x10, + 0x3, 0x8f, 0xff, 0xf6, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x1, 0x6a, 0xdf, 0xff, 0xda, 0x60, 0x0, + 0x0, + + /* U+0074 "t" */ + 0x0, 0x0, 0x0, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x19, 0xf1, 0x0, 0x0, 0x0, 0x4, 0xef, 0xf1, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf1, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xc0, 0x4d, 0xde, 0xff, 0xfd, + 0xdd, 0xa0, 0x0, 0x9, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfe, + 0x76, 0x60, 0x0, 0x3, 0xff, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x6, 0xce, 0xff, 0xc2, + + /* U+0075 "u" */ + 0x3f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x63, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xf6, 0x3f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0x63, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf6, 0x3f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x63, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xf6, 0x3f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x63, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf6, 0x3f, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x63, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf6, 0x3f, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x63, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf6, 0x3f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x63, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xf6, 0x3f, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x62, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf6, + 0xf, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0x60, 0xcf, 0xff, 0x90, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xf6, 0x6, 0xff, 0xff, 0xc5, 0x32, + 0x5a, 0xff, 0xee, 0xff, 0x60, 0xb, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf2, 0xef, 0xf6, 0x0, 0xa, + 0xff, 0xff, 0xff, 0xff, 0xc2, 0xe, 0xff, 0x60, + 0x0, 0x3, 0x9d, 0xff, 0xda, 0x50, 0x0, 0xef, + 0xf6, + + /* U+0076 "v" */ + 0x4f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x50, 0xef, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xe0, 0x8, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf9, 0x0, + 0x2f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0x30, 0x0, 0xcf, 0xff, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xd0, 0x0, 0x6, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf7, 0x0, 0x0, + 0xf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x10, 0x0, 0x0, 0xaf, 0xff, 0x10, 0x0, 0x0, + 0xf, 0xff, 0xb0, 0x0, 0x0, 0x4, 0xff, 0xf7, + 0x0, 0x0, 0x5, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xc0, 0x0, 0x0, 0xbf, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0x20, 0x0, 0x1f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf8, + 0x0, 0x6, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xd0, 0x0, 0xcf, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x30, 0x2f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf8, + 0x8, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xd0, 0xdf, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x5f, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfe, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + + /* U+0077 "w" */ + 0xaf, 0xff, 0x20, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfe, 0x5, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0xe, 0xff, 0x90, 0xf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf4, 0x0, 0xbf, + 0xff, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0x0, 0x6, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x50, + 0x0, 0x0, 0xd, 0xff, 0xa0, 0x0, 0x2f, 0xff, + 0x80, 0x0, 0x0, 0x1f, 0xff, 0xdf, 0xf9, 0x0, + 0x0, 0x1, 0xff, 0xf6, 0x0, 0x0, 0xdf, 0xfc, + 0x0, 0x0, 0x6, 0xff, 0xc8, 0xff, 0xd0, 0x0, + 0x0, 0x6f, 0xff, 0x10, 0x0, 0x8, 0xff, 0xf1, + 0x0, 0x0, 0xaf, 0xf8, 0x5f, 0xff, 0x10, 0x0, + 0xb, 0xff, 0xc0, 0x0, 0x0, 0x3f, 0xff, 0x50, + 0x0, 0xe, 0xff, 0x31, 0xff, 0xf5, 0x0, 0x0, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0xef, 0xf9, 0x0, + 0x2, 0xff, 0xf0, 0xd, 0xff, 0x90, 0x0, 0x4f, + 0xff, 0x20, 0x0, 0x0, 0x9, 0xff, 0xe0, 0x0, + 0x7f, 0xfb, 0x0, 0x9f, 0xfd, 0x0, 0x9, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x20, 0xb, + 0xff, 0x70, 0x5, 0xff, 0xf1, 0x0, 0xef, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf6, 0x0, 0xff, + 0xf3, 0x0, 0x1f, 0xff, 0x50, 0x2f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xb0, 0x4f, 0xfe, + 0x0, 0x0, 0xcf, 0xf9, 0x7, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x8, 0xff, 0xa0, + 0x0, 0x8, 0xff, 0xd0, 0xcf, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xf4, 0xcf, 0xf6, 0x0, + 0x0, 0x4f, 0xff, 0x3f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0x8f, 0xff, 0x20, 0x0, + 0x0, 0xff, 0xfb, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0x50, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x60, 0x0, 0x0, 0x0, + + /* U+0078 "x" */ + 0xb, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfc, 0x0, 0x1e, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xfe, 0x10, 0x0, 0x5f, 0xff, + 0xf2, 0x0, 0x0, 0x2, 0xff, 0xff, 0x40, 0x0, + 0x0, 0xaf, 0xff, 0xc0, 0x0, 0x0, 0xcf, 0xff, + 0x90, 0x0, 0x0, 0x1, 0xef, 0xff, 0x60, 0x0, + 0x7f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0x10, 0x3f, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xfb, 0xd, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xfc, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xfb, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfb, + 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0x10, 0x2f, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x60, 0x0, 0x6f, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xb0, 0x0, + 0x0, 0xcf, 0xff, 0x80, 0x0, 0x0, 0x4f, 0xff, + 0xf2, 0x0, 0x0, 0x2, 0xff, 0xff, 0x40, 0x0, + 0x1e, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xfe, 0x10, 0xa, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfa, 0x5, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf5, + + /* U+0079 "y" */ + 0x2f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x60, 0xbf, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xf1, 0x5, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfa, 0x0, + 0xf, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x40, 0x0, 0x9f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xe0, 0x0, 0x3, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf8, 0x0, 0x0, + 0xd, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0x20, 0x0, 0x0, 0x6f, 0xff, 0x60, 0x0, 0x0, + 0xd, 0xff, 0xc0, 0x0, 0x0, 0x1, 0xff, 0xfc, + 0x0, 0x0, 0x4, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf2, 0x0, 0x0, 0xaf, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x80, 0x0, 0xf, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfd, + 0x0, 0x6, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xf3, 0x0, 0xbf, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x90, 0x1f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfe, + 0x6, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf3, 0xbf, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0x9f, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xef, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x99, 0x9b, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xcf, 0xfc, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+007A "z" */ + 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf7, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x70, 0x5, 0xee, 0xee, + 0xee, 0xee, 0xee, 0xee, 0xef, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xfc, + 0x11, 0x12, 0x22, 0x22, 0x22, 0x22, 0x22, 0x2, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf1, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x12, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + + /* U+007B "{" */ + 0x0, 0x0, 0x0, 0x0, 0x36, 0x78, 0x0, 0x0, + 0x0, 0x5, 0xef, 0xff, 0xf1, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0xdf, 0xff, + 0xeb, 0xb0, 0x0, 0x0, 0x2f, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x29, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xe3, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xd3, 0x0, 0x0, 0x0, + 0x5, 0x8e, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfe, + 0x63, 0x30, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0x10, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x7, 0xce, 0xff, 0x10, + + /* U+007C "|" */ + 0x2f, 0xff, 0x12, 0xff, 0xf1, 0x2f, 0xff, 0x12, + 0xff, 0xf1, 0x2f, 0xff, 0x12, 0xff, 0xf1, 0x2f, + 0xff, 0x12, 0xff, 0xf1, 0x2f, 0xff, 0x12, 0xff, + 0xf1, 0x2f, 0xff, 0x12, 0xff, 0xf1, 0x2f, 0xff, + 0x12, 0xff, 0xf1, 0x2f, 0xff, 0x12, 0xff, 0xf1, + 0x2f, 0xff, 0x12, 0xff, 0xf1, 0x2f, 0xff, 0x12, + 0xff, 0xf1, 0x2f, 0xff, 0x12, 0xff, 0xf1, 0x2f, + 0xff, 0x12, 0xff, 0xf1, 0x2f, 0xff, 0x12, 0xff, + 0xf1, 0x2f, 0xff, 0x12, 0xff, 0xf1, 0x2f, 0xff, + 0x12, 0xff, 0xf1, 0x2f, 0xff, 0x12, 0xff, 0xf1, + 0x2f, 0xff, 0x12, 0xff, 0xf1, 0x2f, 0xff, 0x12, + 0xff, 0xf1, 0x2f, 0xff, 0x12, 0xff, 0xf1, 0x2f, + 0xff, 0x10, + + /* U+007D "}" */ + 0x8, 0x76, 0x40, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0xbb, 0xef, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf9, 0x20, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x3, + 0xef, 0xfd, 0x0, 0x0, 0x0, 0x2, 0xcf, 0xff, + 0xd0, 0x0, 0x0, 0x2, 0xef, 0xfe, 0x85, 0x0, + 0x0, 0x0, 0xcf, 0xfd, 0x10, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x40, 0x0, 0x0, 0x33, 0x6e, 0xff, 0xf1, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xfc, 0x10, 0x0, 0x0, 0xf, + 0xfe, 0xc7, 0x0, 0x0, 0x0, 0x0, + + /* U+007E "~" */ + 0x0, 0x3, 0x8b, 0xcb, 0x83, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0x1, 0xaf, 0xff, 0xff, 0xff, + 0xe7, 0x10, 0x0, 0x0, 0x0, 0xac, 0xc, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x30, 0x0, 0x5d, + 0xfc, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xdf, 0xff, 0xfc, 0x3f, 0xfb, 0x41, 0x3, + 0x8e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x3f, + 0x70, 0x0, 0x0, 0x0, 0x6d, 0xff, 0xff, 0xff, + 0xff, 0x80, 0x35, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x39, 0xdf, 0xfd, 0x92, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00A0 " " */ + + /* U+00A3 "£" */ + 0x0, 0x0, 0x0, 0x0, 0x1, 0x56, 0x76, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4c, + 0xff, 0xff, 0xff, 0xfa, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, + 0x98, 0xae, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xe4, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x2f, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xfa, 0x0, 0x0, 0x7, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf1, + 0x0, 0x0, 0xbf, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0x40, 0x0, 0xd, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xfc, 0xa3, 0x0, + 0x0, 0xef, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xec, 0xef, 0xfe, 0xb9, 0x64, 0x10, 0x2, + 0x5a, 0x30, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe0, 0x6, 0xfe, 0x94, 0x20, 0x1, 0x37, 0xae, + 0xff, 0xff, 0xff, 0xfb, 0x10, 0x5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0x57, 0x76, 0x30, 0x0, + + /* U+00A4 "¤" */ + 0x0, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x20, 0x0, 0x1d, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0x40, 0xc, 0xff, 0xc0, + 0x6, 0xbe, 0xff, 0xc8, 0x20, 0x7f, 0xff, 0x31, + 0xdf, 0xff, 0xce, 0xff, 0xff, 0xff, 0xff, 0xbf, + 0xff, 0xf5, 0x1, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x1, 0xdf, 0xff, + 0xfc, 0x75, 0x6a, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0xe, 0xff, 0xf5, 0x0, 0x0, 0x2, 0xdf, 0xff, + 0x40, 0x0, 0x6, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x2, 0xef, 0xfc, 0x0, 0x0, 0xbf, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf1, 0x0, 0xe, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x40, 0x0, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xf5, 0x0, 0xe, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x40, 0x0, 0xbf, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf1, + 0x0, 0x6, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xfc, 0x0, 0x0, 0xe, 0xff, 0xf5, 0x0, + 0x0, 0x2, 0xdf, 0xff, 0x40, 0x0, 0x1, 0xdf, + 0xff, 0xfc, 0x75, 0x6a, 0xff, 0xff, 0xf4, 0x0, + 0x1, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf4, 0x1, 0xdf, 0xff, 0xce, 0xff, 0xff, + 0xff, 0xff, 0xbf, 0xff, 0xf5, 0x1c, 0xff, 0xc0, + 0x6, 0xbe, 0xff, 0xc8, 0x10, 0x7f, 0xff, 0x40, + 0x1d, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0x40, 0x0, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x20, 0x0, + + /* U+00A5 "¥" */ + 0xbf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf1, 0x2f, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x70, + 0x9, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xfe, 0x0, 0x1, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf6, 0x0, + 0x0, 0x7f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xd0, 0x0, 0x0, 0xe, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x40, 0x0, + 0x0, 0x6, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x30, 0x0, 0x0, 0x1f, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xc0, 0x0, 0x0, 0x8f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf4, 0x0, 0x1, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xfd, 0x0, 0x9, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x60, 0x2f, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xd0, 0x9f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xf7, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, + 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, + 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x0, 0x8, 0xdd, 0xdd, 0xdd, + 0xdd, 0xff, 0xfe, 0xdd, 0xdd, 0xdd, 0xdd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00A6 "¦" */ + 0x2f, 0xff, 0x12, 0xff, 0xf1, 0x2f, 0xff, 0x12, + 0xff, 0xf1, 0x2f, 0xff, 0x12, 0xff, 0xf1, 0x2f, + 0xff, 0x12, 0xff, 0xf1, 0x2f, 0xff, 0x12, 0xff, + 0xf1, 0x2f, 0xff, 0x12, 0xff, 0xf1, 0x2f, 0xff, + 0x12, 0xff, 0xf1, 0x2f, 0xff, 0x12, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xf1, 0x2f, 0xff, 0x12, 0xff, + 0xf1, 0x2f, 0xff, 0x12, 0xff, 0xf1, 0x2f, 0xff, + 0x12, 0xff, 0xf1, 0x2f, 0xff, 0x12, 0xff, 0xf1, + 0x2f, 0xff, 0x12, 0xff, 0xf1, 0x2f, 0xff, 0x12, + 0xff, 0xf1, 0x2f, 0xff, 0x12, 0xff, 0xf1, 0x2f, + 0xff, 0x10, + + /* U+00A7 "§" */ + 0x0, 0x0, 0x0, 0x1, 0x57, 0x76, 0x41, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2b, 0xff, 0xff, + 0xff, 0xfb, 0x30, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xfe, 0xa8, 0x9e, 0xff, 0xff, + 0x40, 0x0, 0x0, 0xb, 0xff, 0xf8, 0x0, 0x0, + 0x9, 0xff, 0xfe, 0x0, 0x0, 0x1, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf4, 0x0, 0x0, + 0x3f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x90, 0x0, 0x3, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x2, 0xcb, 0x96, 0x0, 0x0, 0xf, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xd2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xfc, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xcf, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xfa, 0x7f, 0xff, 0xff, 0xd4, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf6, 0x0, 0x3d, + 0xff, 0xff, 0xfa, 0x10, 0x0, 0x0, 0xef, 0xf9, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xfe, 0x30, 0x0, + 0x2f, 0xff, 0x30, 0x0, 0x0, 0x2, 0xbf, 0xff, + 0xff, 0x60, 0x3, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0x50, 0x2f, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x2d, 0xff, 0xfe, 0x0, + 0xef, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xf4, 0x7, 0xff, 0xfd, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x70, 0xc, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf7, 0x0, + 0xb, 0xff, 0xff, 0xc3, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x50, 0x0, 0x8, 0xff, 0xff, 0xf9, 0x10, + 0x0, 0x7, 0xff, 0xf1, 0x0, 0x0, 0x4, 0xef, + 0xff, 0xfe, 0x50, 0x5, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xba, 0xff, 0xe5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2c, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xbf, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xc0, 0x0, 0x4, 0x79, + 0x90, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x0, + 0x0, 0xdf, 0xff, 0x10, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf1, 0x0, 0x9, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x0, 0x0, 0x3f, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xb0, 0x0, + 0x0, 0xaf, 0xff, 0xf9, 0x31, 0x14, 0xaf, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xe5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x27, 0xbe, 0xff, 0xeb, 0x60, 0x0, + 0x0, 0x0, + + /* U+00A8 "¨" */ + 0x12, 0x22, 0x0, 0x0, 0x22, 0x21, 0xcf, 0xff, + 0x10, 0x1, 0xff, 0xfc, 0xcf, 0xff, 0x10, 0x1, + 0xff, 0xfc, 0xcf, 0xff, 0x10, 0x1, 0xff, 0xfc, + 0xcf, 0xff, 0x10, 0x1, 0xff, 0xfc, + + /* U+00A9 "©" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x36, 0x78, + 0x86, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4a, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1b, 0xff, 0xfe, 0xa5, 0x21, 0x1, 0x25, + 0xaf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2d, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x18, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xc1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xcf, 0xfd, 0x10, 0x0, 0x0, 0xc, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xfc, 0x0, 0x0, 0x8, 0xff, 0xb0, + 0x0, 0x0, 0x17, 0xce, 0xff, 0xc8, 0x20, 0x0, + 0x0, 0xaf, 0xf8, 0x0, 0x2, 0xff, 0xd0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0xef, 0xf2, 0x0, 0x9f, 0xf4, 0x0, 0x0, + 0x8f, 0xff, 0xa6, 0x46, 0x9f, 0xff, 0x70, 0x0, + 0x4, 0xff, 0xa0, 0xf, 0xfb, 0x0, 0x0, 0x4f, + 0xff, 0x30, 0x0, 0x0, 0x2e, 0xff, 0x20, 0x0, + 0xc, 0xff, 0x15, 0xff, 0x50, 0x0, 0xc, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x4f, 0xf7, 0x0, 0x0, + 0x6f, 0xf5, 0x9f, 0xf0, 0x0, 0x2, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x41, 0x0, 0x0, 0x0, + 0xff, 0x9d, 0xfc, 0x0, 0x0, 0x6f, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xfc, 0xef, 0xa0, 0x0, 0x8, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xef, 0xf9, 0x0, 0x0, 0x9f, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xfe, + 0xff, 0xa0, 0x0, 0x8, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xee, + 0xfb, 0x0, 0x0, 0x7f, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfd, 0xcf, + 0xd0, 0x0, 0x3, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x99, 0x40, 0x0, 0x0, 0xef, 0xb8, 0xff, + 0x20, 0x0, 0xe, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x2f, 0xfb, 0x0, 0x0, 0x3f, 0xf7, 0x4f, 0xf7, + 0x0, 0x0, 0x6f, 0xfb, 0x0, 0x0, 0x0, 0x1d, + 0xff, 0x50, 0x0, 0x8, 0xff, 0x30, 0xef, 0xe1, + 0x0, 0x0, 0xcf, 0xfd, 0x51, 0x2, 0x7e, 0xff, + 0xb0, 0x0, 0x1, 0xff, 0xd0, 0x6, 0xff, 0x80, + 0x0, 0x1, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x9f, 0xf5, 0x0, 0xd, 0xff, 0x50, + 0x0, 0x0, 0x7e, 0xff, 0xff, 0xfd, 0x60, 0x0, + 0x0, 0x5f, 0xfc, 0x0, 0x0, 0x3f, 0xff, 0x30, + 0x0, 0x0, 0x2, 0x45, 0x42, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x20, 0x0, 0x0, 0x6f, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x91, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x9f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf8, + 0x20, 0x0, 0x0, 0x0, 0x28, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3d, 0xff, 0xff, + 0xeb, 0x98, 0x9b, 0xef, 0xff, 0xfc, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x38, 0xbe, + 0xff, 0xfd, 0xb7, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+00AA "ª" */ + 0x0, 0x1, 0x8d, 0xfe, 0xc6, 0x0, 0xff, 0xf0, + 0x0, 0x3e, 0xff, 0xff, 0xff, 0xb4, 0xff, 0xb0, + 0x1, 0xef, 0xfd, 0x65, 0x8f, 0xfe, 0xff, 0x60, + 0x9, 0xff, 0xd0, 0x0, 0x4, 0xff, 0xff, 0x20, + 0xf, 0xff, 0x40, 0x0, 0x0, 0xaf, 0xff, 0x0, + 0x3f, 0xff, 0x0, 0x0, 0x0, 0x5f, 0xfb, 0x0, + 0x4f, 0xfd, 0x0, 0x0, 0x0, 0x3f, 0xf8, 0x0, + 0x5f, 0xfd, 0x0, 0x0, 0x0, 0x2f, 0xf6, 0x0, + 0x4f, 0xfe, 0x0, 0x0, 0x0, 0x3f, 0xf8, 0x0, + 0x2f, 0xff, 0x0, 0x0, 0x0, 0x6f, 0xfb, 0x0, + 0xe, 0xff, 0x50, 0x0, 0x0, 0xcf, 0xfe, 0x0, + 0x8, 0xff, 0xc0, 0x0, 0x6, 0xff, 0xff, 0x20, + 0x1, 0xef, 0xfc, 0x65, 0x9f, 0xfe, 0xff, 0x70, + 0x0, 0x3e, 0xff, 0xff, 0xff, 0xc3, 0xff, 0xc0, + 0x0, 0x1, 0x8d, 0xff, 0xc7, 0x0, 0x8a, 0xa0, + + /* U+00AB "«" */ + 0x0, 0x0, 0x0, 0x6, 0x77, 0x20, 0x0, 0x6, + 0x77, 0x20, 0x0, 0x0, 0x5, 0xff, 0xd0, 0x0, + 0x6, 0xff, 0xd0, 0x0, 0x0, 0x1, 0xef, 0xf4, + 0x0, 0x2, 0xff, 0xf3, 0x0, 0x0, 0x0, 0xbf, + 0xfa, 0x0, 0x0, 0xcf, 0xfa, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x20, 0x0, 0x7f, 0xff, 0x10, 0x0, + 0x0, 0x2f, 0xff, 0x80, 0x0, 0x3f, 0xff, 0x70, + 0x0, 0x0, 0xd, 0xff, 0xe0, 0x0, 0xd, 0xff, + 0xd0, 0x0, 0x0, 0x9, 0xff, 0xf5, 0x0, 0x9, + 0xff, 0xf4, 0x0, 0x0, 0x4, 0xff, 0xfc, 0x0, + 0x4, 0xff, 0xfb, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x30, 0x0, 0xef, 0xff, 0x20, 0x0, 0x0, 0xa, + 0xff, 0xf7, 0x0, 0x9, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf1, 0x0, 0xd, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xa0, 0x0, 0x3f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x30, + 0x0, 0x8f, 0xff, 0x30, 0x0, 0x0, 0x0, 0xcf, + 0xfc, 0x0, 0x0, 0xdf, 0xfc, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf5, 0x0, 0x2, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xe0, 0x0, 0x7, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0xa, 0xff, 0x70, 0x0, + 0xc, 0xff, 0x80, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0x10, 0x0, 0x1f, 0xff, 0x20, + + /* U+00AC "¬" */ + 0x46, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, + 0x66, 0x66, 0x1a, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf3, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3a, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x30, + + /* U+00AD "­" */ + 0x7a, 0xaa, 0xaa, 0xaa, 0xaa, 0xa7, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xfa, + + /* U+00AE "®" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x36, 0x78, + 0x86, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4a, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1b, 0xff, 0xfe, 0xa5, 0x21, 0x1, 0x25, + 0xaf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2d, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x18, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xc1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xcf, 0xfd, 0x10, 0x0, 0x0, 0xc, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xfc, 0x0, 0x0, 0x8, 0xff, 0xb0, + 0x1, 0x33, 0x33, 0x33, 0x32, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xf8, 0x0, 0x2, 0xff, 0xd0, 0x0, + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xc5, 0x0, 0x0, + 0x0, 0xef, 0xf2, 0x0, 0x9f, 0xf4, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x4, 0xff, 0xa0, 0xf, 0xfb, 0x0, 0x0, 0x4f, + 0xf6, 0x0, 0x0, 0x28, 0xff, 0xf1, 0x0, 0x0, + 0xc, 0xff, 0x15, 0xff, 0x50, 0x0, 0x4, 0xff, + 0x60, 0x0, 0x0, 0x8, 0xff, 0x60, 0x0, 0x0, + 0x6f, 0xf5, 0x9f, 0xf0, 0x0, 0x0, 0x4f, 0xf6, + 0x0, 0x0, 0x0, 0x5f, 0xf7, 0x0, 0x0, 0x0, + 0xff, 0x9d, 0xfc, 0x0, 0x0, 0x4, 0xff, 0x60, + 0x0, 0x0, 0x9, 0xff, 0x50, 0x0, 0x0, 0xd, + 0xfc, 0xef, 0xa0, 0x0, 0x0, 0x4f, 0xf6, 0x0, + 0x0, 0x39, 0xff, 0xd0, 0x0, 0x0, 0x0, 0xbf, + 0xef, 0xf9, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, 0xa, 0xfe, + 0xff, 0xa0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, + 0xfc, 0x81, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xee, + 0xfb, 0x0, 0x0, 0x4, 0xff, 0x84, 0x59, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xfd, 0xcf, + 0xd0, 0x0, 0x0, 0x4f, 0xf6, 0x0, 0x3, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xb8, 0xff, + 0x20, 0x0, 0x4, 0xff, 0x60, 0x0, 0x6, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x3f, 0xf7, 0x4f, 0xf7, + 0x0, 0x0, 0x4f, 0xf6, 0x0, 0x0, 0xc, 0xff, + 0x40, 0x0, 0x0, 0x8, 0xff, 0x30, 0xef, 0xe1, + 0x0, 0x4, 0xff, 0x60, 0x0, 0x0, 0x2f, 0xfe, + 0x10, 0x0, 0x1, 0xff, 0xd0, 0x6, 0xff, 0x80, + 0x0, 0x4f, 0xf6, 0x0, 0x0, 0x0, 0x9f, 0xf9, + 0x0, 0x0, 0x9f, 0xf5, 0x0, 0xd, 0xff, 0x50, + 0x4, 0xff, 0x60, 0x0, 0x0, 0x1, 0xef, 0xf3, + 0x0, 0x5f, 0xfc, 0x0, 0x0, 0x3f, 0xff, 0x30, + 0x3, 0x31, 0x0, 0x0, 0x0, 0x2, 0x33, 0x20, + 0x3f, 0xff, 0x20, 0x0, 0x0, 0x6f, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x91, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x9f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf8, + 0x20, 0x0, 0x0, 0x0, 0x28, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3d, 0xff, 0xff, + 0xeb, 0x98, 0x9b, 0xef, 0xff, 0xfc, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x38, 0xbe, + 0xff, 0xfd, 0xb7, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+00B0 "°" */ + 0x0, 0x0, 0x1, 0x21, 0x0, 0x0, 0x0, 0x0, + 0x6d, 0xff, 0xfc, 0x40, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x6f, 0xf9, 0x20, 0x3b, + 0xff, 0x30, 0xe, 0xf9, 0x0, 0x0, 0xc, 0xfb, + 0x3, 0xff, 0x10, 0x0, 0x0, 0x4f, 0xf0, 0x4f, + 0xf0, 0x0, 0x0, 0x2, 0xff, 0x12, 0xff, 0x20, + 0x0, 0x0, 0x5f, 0xf0, 0xd, 0xfb, 0x0, 0x0, + 0x1d, 0xfa, 0x0, 0x5f, 0xfc, 0x53, 0x6e, 0xff, + 0x20, 0x0, 0x6f, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x3a, 0xef, 0xe9, 0x20, 0x0, + + /* U+00B1 "±" */ + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3a, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf3, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x33, 0x66, 0x66, 0x66, 0x6a, + 0xff, 0xf6, 0x66, 0x66, 0x66, 0x61, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xaa, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0x66, 0x66, 0x66, + 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x61, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x3a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf3, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, + + /* U+00B2 "²" */ + 0x0, 0x3, 0x9d, 0xff, 0xec, 0x71, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0xfe, 0x20, 0x5, 0xff, + 0xfb, 0x77, 0xaf, 0xff, 0xc0, 0xc, 0xff, 0x90, + 0x0, 0x5, 0xff, 0xf1, 0x6, 0x89, 0x10, 0x0, + 0x1, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x2d, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xfc, 0x20, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfc, 0x77, + 0x77, 0x77, 0x72, 0x1e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf4, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf4, + + /* U+00B3 "³" */ + 0x0, 0x4, 0xbe, 0xff, 0xeb, 0x50, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x6, 0xff, + 0xf8, 0x55, 0xaf, 0xff, 0x50, 0xa, 0xef, 0x50, + 0x0, 0xc, 0xff, 0x70, 0x0, 0x1, 0x0, 0x0, + 0xd, 0xff, 0x50, 0x0, 0x0, 0x0, 0x36, 0xcf, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x4c, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xf1, 0x15, 0x66, + 0x0, 0x0, 0x0, 0xff, 0xf3, 0x1f, 0xff, 0x40, + 0x0, 0x8, 0xff, 0xf1, 0xa, 0xff, 0xfa, 0x77, + 0xcf, 0xff, 0xa0, 0x0, 0xbf, 0xff, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x5, 0xbe, 0xff, 0xea, 0x40, + 0x0, + + /* U+00B5 "µ" */ + 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0x72, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf7, 0x2f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x72, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf7, 0x2f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x72, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xf7, 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x72, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xf7, 0x2f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x72, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf7, 0x2f, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x72, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf7, 0x2f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0x72, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xf7, 0x2f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x72, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf7, + 0x2f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0x72, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xf7, 0x2f, 0xff, 0xff, 0xd4, 0x0, + 0x2, 0xbf, 0xff, 0xff, 0x72, 0xff, 0xff, 0xff, + 0xfe, 0xde, 0xff, 0xff, 0xef, 0xf7, 0x2f, 0xff, + 0x9d, 0xff, 0xff, 0xff, 0xff, 0x5d, 0xff, 0x72, + 0xff, 0xf8, 0x1a, 0xff, 0xff, 0xfd, 0x40, 0xdf, + 0xf7, 0x2f, 0xff, 0x80, 0x1, 0x57, 0x63, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00B6 "¶" */ + 0x0, 0x0, 0x0, 0x6a, 0xde, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xc8, 0x88, 0x8e, 0xff, 0xd8, 0x84, + 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0xd, 0xff, 0xa0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x90, 0x0, 0xd, 0xff, 0xa0, 0x0, + 0xd, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0xd, 0xff, 0xa0, 0x0, 0xf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x90, 0x0, 0xd, 0xff, 0xa0, 0x0, + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0xd, 0xff, 0xa0, 0x0, 0xf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x90, 0x0, 0xd, 0xff, 0xa0, 0x0, + 0xd, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0xd, 0xff, 0xa0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x90, 0x0, 0xd, 0xff, 0xa0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0xd, 0xff, 0xa0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xff, 0xff, 0x90, 0x0, 0xd, 0xff, 0xa0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0xd, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x7e, 0xff, + 0xff, 0xff, 0x90, 0x0, 0xd, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x58, 0xaf, 0xff, 0x90, 0x0, + 0xd, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0x90, 0x0, 0xd, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x90, 0x0, + 0xd, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0x90, 0x0, 0xd, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x90, 0x0, + 0xd, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0x90, 0x0, 0xd, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x90, 0x0, + 0xd, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0x90, 0x0, 0xd, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x90, 0x0, + 0xd, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0x90, 0x0, 0xd, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x90, 0x0, + 0xd, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0x90, 0x0, 0xd, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x90, 0x0, + 0xd, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0x90, 0x0, 0xd, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x90, 0x0, + 0xd, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0x90, 0x0, 0xd, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x90, 0x0, + 0xd, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0x90, 0x0, 0xd, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x90, 0x0, + 0xd, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0x90, 0x0, 0xd, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x90, 0x0, + 0xd, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0x90, 0x0, 0xd, 0xff, 0xa0, 0x0, + + /* U+00B7 "·" */ + 0x2, 0x22, 0x23, 0xff, 0xff, 0x3f, 0xff, 0xf3, + 0xff, 0xff, 0x3f, 0xff, 0xf0, + + /* U+00BB "»" */ + 0x6, 0x77, 0x10, 0x0, 0x7, 0x77, 0x10, 0x0, + 0x0, 0x0, 0x7f, 0xfb, 0x0, 0x0, 0x7f, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf6, 0x0, 0x0, + 0xdf, 0xf6, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf2, + 0x0, 0x5, 0xff, 0xf2, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xc0, 0x0, 0xb, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0x80, 0x0, 0x2f, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0x30, 0x0, 0x9f, + 0xff, 0x30, 0x0, 0x0, 0x0, 0xef, 0xfd, 0x0, + 0x1, 0xef, 0xfd, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xf9, 0x0, 0x6, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf4, 0x0, 0xd, 0xff, 0xf4, 0x0, + 0x0, 0x1, 0xff, 0xfe, 0x10, 0x2, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0xaf, 0xff, 0x40, 0x0, 0xbf, + 0xff, 0x40, 0x0, 0x0, 0x3f, 0xff, 0x90, 0x0, + 0x4f, 0xff, 0x90, 0x0, 0x0, 0xc, 0xff, 0xd0, + 0x0, 0xd, 0xff, 0xd0, 0x0, 0x0, 0x6, 0xff, + 0xf3, 0x0, 0x7, 0xff, 0xf3, 0x0, 0x0, 0x1, + 0xef, 0xf7, 0x0, 0x1, 0xef, 0xf7, 0x0, 0x0, + 0x0, 0x9f, 0xfc, 0x0, 0x0, 0x9f, 0xfb, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x20, 0x0, 0x2f, 0xfe, + 0x10, 0x0, 0x0, 0xc, 0xff, 0x60, 0x0, 0xb, + 0xff, 0x50, 0x0, 0x0, 0x0, + + /* U+00BD "½" */ + 0x0, 0x0, 0x1d, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x1c, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x4e, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xa0, 0x0, + 0x0, 0x3, 0xaf, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0xdf, 0xfe, 0x8f, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xf4, 0x0, + 0x0, 0x0, 0xd, 0xe8, 0x3, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x30, 0x0, 0x3f, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x6f, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xfc, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x55, 0x40, 0x0, 0x0, 0xd, 0xff, + 0x50, 0x0, 0x0, 0x4, 0x66, 0x52, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xa0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xfe, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xd0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xf3, 0x0, 0x0, 0x8f, 0xfe, 0x51, 0x3, 0xcf, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xf7, 0x0, 0x0, 0xe, 0xff, 0x50, 0x0, 0x2, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xfc, 0x0, 0x0, 0x0, 0x12, 0x40, 0x0, 0x0, + 0x1f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2c, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xe4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xc2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xd7, 0x77, 0x77, 0x77, 0x20, 0x0, + 0xd, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x9, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, + 0x1, 0x78, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0384 "΄" */ + 0x0, 0x9, 0xaa, 0xa9, 0x0, 0x4, 0xff, 0xff, + 0x30, 0x0, 0xcf, 0xff, 0x60, 0x0, 0x4f, 0xff, + 0x90, 0x0, 0xb, 0xff, 0xc0, 0x0, 0x3, 0xff, + 0xe1, 0x0, 0x0, + + /* U+0386 "Ά" */ + 0x0, 0x0, 0x6f, 0xff, 0xf4, 0x0, 0xaf, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x70, 0x1, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xfa, 0x0, 0x6, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xd0, 0x0, 0xd, 0xff, 0xcf, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x20, + 0x0, 0x3f, 0xff, 0x4f, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7a, 0xa4, 0x0, 0x0, + 0x9f, 0xff, 0xa, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xfb, 0x5, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf6, + 0x0, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf1, 0x0, + 0xaf, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xb0, 0x0, 0x4f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x50, 0x0, 0xe, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0x0, 0x0, 0x8, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf9, 0x0, 0x0, 0x2, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x20, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xfd, 0x33, 0x33, 0x33, 0x33, + 0x37, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x8, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x70, 0x0, + 0x0, 0xe, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xd0, 0x0, 0x0, + 0x4f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xf4, 0x0, 0x0, 0xaf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfa, 0x0, 0x1, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0x10, 0x7, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0x70, 0xd, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xe0, + + /* U+0388 "Έ" */ + 0x0, 0x5f, 0xff, 0xf5, 0x0, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x0, 0xd, 0xff, 0xf8, 0x0, 0xc, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf0, 0x4, 0xff, 0xfb, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x0, 0xcf, 0xfe, 0x10, 0x0, 0xc, 0xff, + 0xf9, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, + 0x88, 0x70, 0x4f, 0xff, 0x30, 0x0, 0x0, 0xcf, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xaa, 0x50, 0x0, 0x0, 0xc, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x98, + 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x98, 0x88, 0x88, 0x88, + 0x88, 0x88, 0x88, 0x88, 0x88, 0x50, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + + /* U+0389 "Ή" */ + 0x0, 0x5f, 0xff, 0xf5, 0x9, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf0, 0xc, 0xff, 0xf9, 0x0, 0x9f, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0x4, 0xff, 0xfc, 0x0, 0x9, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf0, 0xcf, 0xfe, 0x10, 0x0, 0x9f, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0x4f, 0xff, 0x30, 0x0, 0x9, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf7, 0xaa, 0x50, 0x0, 0x0, 0x9f, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xfa, 0x88, 0x88, 0x88, + 0x88, 0x88, 0x88, 0x88, 0x8f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + + /* U+038A "Ί" */ + 0x0, 0x5f, 0xff, 0xf5, 0x9, 0xff, 0xf5, 0x0, + 0xcf, 0xff, 0x90, 0x9, 0xff, 0xf5, 0x4, 0xff, + 0xfc, 0x0, 0x9, 0xff, 0xf5, 0xc, 0xff, 0xe1, + 0x0, 0x9, 0xff, 0xf5, 0x4f, 0xff, 0x30, 0x0, + 0x9, 0xff, 0xf5, 0x7a, 0xa5, 0x0, 0x0, 0x9, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xf5, + + /* U+038C "Ό" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x14, + 0x67, 0x76, 0x52, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0x50, 0x0, 0x7, 0xcf, + 0xff, 0xff, 0xff, 0xfe, 0x92, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x80, 0x0, 0x6e, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x10, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xb0, 0x1, 0xbf, 0xff, + 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xfe, 0x30, + 0x0, 0x0, 0xc, 0xff, 0xe1, 0x1, 0xdf, 0xff, + 0xff, 0x84, 0x0, 0x0, 0x27, 0xcf, 0xff, 0xff, + 0x40, 0x0, 0x4, 0xff, 0xf3, 0x0, 0xbf, 0xff, + 0xf9, 0x10, 0x0, 0x0, 0x0, 0x0, 0x6e, 0xff, + 0xff, 0x20, 0x0, 0x7a, 0xa5, 0x0, 0x8f, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xe0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0x60, 0x0, 0x0, 0x5f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xfb, 0x0, 0x0, 0x9, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf0, 0x0, 0x0, + 0xdf, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x30, 0x0, + 0xf, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf5, 0x0, + 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x70, + 0x0, 0x2f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf8, + 0x0, 0x2, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0x80, 0x0, 0x2f, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf7, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x50, 0x0, 0xe, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf4, 0x0, 0x0, 0xaf, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0x0, 0x0, 0x6, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xc0, 0x0, 0x0, 0x1f, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xf7, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xef, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xef, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1d, 0xff, 0xff, 0xe8, 0x30, 0x0, 0x1, + 0x6c, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1b, 0xff, 0xff, 0xff, 0xfe, 0xef, + 0xff, 0xff, 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xa1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6c, 0xff, 0xff, + 0xff, 0xff, 0xe9, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x46, + 0x77, 0x75, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+038E "Ύ" */ + 0x0, 0x5f, 0xff, 0xf5, 0x0, 0xdf, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xe1, 0x0, 0xdf, 0xff, 0x80, 0x0, + 0x3f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0x50, 0x4, 0xff, + 0xfb, 0x0, 0x0, 0x8, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf9, + 0x0, 0xc, 0xff, 0xe1, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xd0, 0x0, 0x4f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0x30, 0x0, 0x7a, + 0xa5, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0x30, 0x0, 0x0, 0xd, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xd0, 0x0, 0x0, + 0x8f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xf7, 0x0, 0x3, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x20, 0xd, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xb0, + 0x7f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf5, 0xff, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+038F "Ώ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x14, + 0x67, 0x76, 0x41, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf5, 0x0, 0x0, 0x7d, 0xff, + 0xff, 0xff, 0xff, 0xd7, 0x10, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x80, 0x0, 0x6e, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe6, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xfb, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xfe, 0xef, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0xc, 0xff, 0xe1, 0x0, 0xbf, 0xff, 0xff, 0x93, + 0x0, 0x0, 0x4a, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x4f, 0xff, 0x30, 0x9, 0xff, 0xff, 0xc2, 0x0, + 0x0, 0x0, 0x0, 0x3d, 0xff, 0xff, 0x60, 0x0, + 0x7a, 0xa5, 0x0, 0x4f, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x20, + 0x0, 0x0, 0xa, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x80, + 0x0, 0x0, 0xe, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xc0, + 0x0, 0x0, 0x2f, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf0, + 0x0, 0x0, 0x5f, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf2, + 0x0, 0x0, 0x6f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf3, + 0x0, 0x0, 0x7f, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf4, + 0x0, 0x0, 0x7f, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf4, + 0x0, 0x0, 0x6f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf3, + 0x0, 0x0, 0x4f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf1, + 0x0, 0x0, 0x1f, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xe0, + 0x0, 0x0, 0xc, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x90, + 0x0, 0x0, 0x7, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x40, + 0x0, 0x0, 0x1, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfc, 0x10, + 0x0, 0x0, 0x2, 0xdf, 0xfe, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x68, 0x88, 0x88, 0xcf, 0xff, 0xf7, + 0x0, 0x0, 0x9f, 0xff, 0xfa, 0x88, 0x88, 0x85, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + + /* U+0390 "ΐ" */ + 0x0, 0x0, 0x0, 0x2, 0x88, 0x83, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xd0, 0x0, 0x0, + 0xbe, 0xea, 0x0, 0x3f, 0xff, 0x26, 0xee, 0xe1, + 0xcf, 0xfc, 0x0, 0xaf, 0xf5, 0x6, 0xff, 0xf2, + 0xcf, 0xfc, 0x2, 0xff, 0x90, 0x6, 0xff, 0xf2, + 0xcf, 0xfc, 0xa, 0xfd, 0x0, 0x6, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf8, 0x0, 0x0, 0x0, + + /* U+0391 "Α" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xdf, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0x4f, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xb, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xfb, 0x5, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf6, + 0x0, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf1, 0x0, + 0xaf, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xb0, 0x0, 0x4f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x50, 0x0, 0xe, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0x0, 0x0, 0x8, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xfa, 0x0, 0x0, 0x2, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x20, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xfd, 0x33, 0x33, 0x33, 0x33, + 0x37, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x8, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x70, 0x0, + 0x0, 0xe, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xd0, 0x0, 0x0, + 0x4f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xf4, 0x0, 0x0, 0xaf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfa, 0x0, 0x1, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0x10, 0x7, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0x70, 0xd, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xe0, + + /* U+0392 "Β" */ + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xed, 0xb7, + 0x20, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xa1, 0x0, 0x0, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe2, 0x0, 0xe, 0xff, 0xf8, 0x88, 0x88, 0x88, + 0x8a, 0xcf, 0xff, 0xff, 0xe1, 0x0, 0xef, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x90, 0xe, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0x0, 0xef, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf3, + 0xe, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0x40, 0xef, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf4, 0xe, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x20, 0xef, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xe0, 0xe, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf6, 0x0, 0xef, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x13, 0x7d, 0xff, 0xfa, 0x0, 0xe, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x10, 0x0, 0xe, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, + 0xef, 0xff, 0x88, 0x88, 0x88, 0x88, 0x8a, 0xdf, + 0xff, 0xff, 0xb0, 0xe, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x18, 0xff, 0xff, 0x90, 0xef, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0x2e, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xf8, 0xef, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xbe, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xfc, 0xef, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xbe, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf9, 0xef, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x4e, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xd0, 0xef, 0xff, 0x88, 0x88, 0x88, + 0x88, 0x89, 0xcf, 0xff, 0xff, 0xf3, 0xe, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb2, 0x0, 0xe, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xed, 0xa7, 0x20, 0x0, + 0x0, + + /* U+0393 "Γ" */ + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf2, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf2, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0xaf, 0xff, + 0xa8, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x81, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0394 "Δ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xcf, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0x4f, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xb, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xfb, 0x5, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf6, + 0x0, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf1, 0x0, + 0xaf, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xb0, 0x0, 0x4f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x50, 0x0, 0xe, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0x0, 0x0, 0x8, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf9, 0x0, 0x0, 0x2, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x60, 0x0, + 0x0, 0xe, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xd0, 0x0, 0x0, + 0x5f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf3, 0x0, 0x0, 0xbf, + 0xff, 0xc8, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, + 0x88, 0x8f, 0xff, 0xfa, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x10, 0x7, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x70, 0xd, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe0, + + /* U+0395 "Ε" */ + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x1a, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x1a, 0xff, 0xfa, 0x88, 0x88, 0x88, + 0x88, 0x88, 0x88, 0x88, 0x88, 0x80, 0xaf, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf0, 0xa, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, + 0xaf, 0xff, 0xa8, 0x88, 0x88, 0x88, 0x88, 0x88, + 0x88, 0x88, 0x70, 0xa, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xa8, 0x88, 0x88, + 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x6a, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xca, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfc, + + /* U+0396 "Ζ" */ + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x4, 0x88, + 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xdf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfc, + 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, + 0x88, 0x43, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x83, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + + /* U+0397 "Η" */ + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0xa8, 0x88, 0x88, 0x88, 0x88, 0x88, + 0x88, 0x88, 0xff, 0xff, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + + /* U+0398 "Θ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x36, 0x77, + 0x75, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xa3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xb2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xf9, 0x41, 0x0, 0x1, 0x6b, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfb, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x4d, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x5, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xcf, 0xff, 0xe1, + 0x0, 0x0, 0xe, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xfa, 0x0, + 0x0, 0x7f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x20, 0x0, + 0xef, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x90, 0x3, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xe0, 0x7, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf2, 0xb, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf6, 0xd, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xf8, 0xe, 0xff, 0xf3, 0x0, 0x4, 0x77, + 0x77, 0x77, 0x77, 0x77, 0x72, 0x0, 0x7, 0xff, + 0xf9, 0xf, 0xff, 0xf2, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x6, 0xff, 0xfa, + 0xf, 0xff, 0xf1, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0x6, 0xff, 0xfa, 0xf, + 0xff, 0xf2, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf4, 0x0, 0x7, 0xff, 0xf9, 0xe, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xf8, 0xb, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf6, 0x8, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf2, 0x3, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xe0, 0x0, 0xef, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x90, 0x0, 0x7f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x20, + 0x0, 0xe, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xfa, 0x0, 0x0, + 0x6, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xcf, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xfa, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x3d, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xf8, 0x30, 0x0, 0x1, 0x5b, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xff, 0xee, 0xff, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xa3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x36, + 0x77, 0x75, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0399 "Ι" */ + 0x2f, 0xff, 0xd2, 0xff, 0xfd, 0x2f, 0xff, 0xd2, + 0xff, 0xfd, 0x2f, 0xff, 0xd2, 0xff, 0xfd, 0x2f, + 0xff, 0xd2, 0xff, 0xfd, 0x2f, 0xff, 0xd2, 0xff, + 0xfd, 0x2f, 0xff, 0xd2, 0xff, 0xfd, 0x2f, 0xff, + 0xd2, 0xff, 0xfd, 0x2f, 0xff, 0xd2, 0xff, 0xfd, + 0x2f, 0xff, 0xd2, 0xff, 0xfd, 0x2f, 0xff, 0xd2, + 0xff, 0xfd, 0x2f, 0xff, 0xd2, 0xff, 0xfd, 0x2f, + 0xff, 0xd2, 0xff, 0xfd, 0x2f, 0xff, 0xd2, 0xff, + 0xfd, 0x2f, 0xff, 0xd2, 0xff, 0xfd, 0x2f, 0xff, + 0xd2, 0xff, 0xfd, + + /* U+039A "Κ" */ + 0xef, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xfc, 0x1e, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xfc, + 0x10, 0xef, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xfc, 0x0, 0xe, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xfb, + 0x0, 0x0, 0xef, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xfb, 0x0, 0x0, 0xe, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x10, 0x0, + 0x0, 0x8f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xf1, 0x0, 0x0, 0x8f, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x10, + 0x0, 0x8f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf1, 0x0, 0x8f, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x10, 0x8f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf1, 0x8f, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0x9f, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0xf5, + 0x8f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xf4, 0x0, 0xcf, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf4, + 0x0, 0x2, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xf4, 0x0, 0x0, 0x6, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0xef, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xfd, 0x10, 0x0, 0x0, 0xe, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xf6, 0x0, 0x0, 0xe, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf2, 0x0, 0x0, 0xef, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xd0, 0x0, + 0xe, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xa0, 0x0, 0xef, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0x50, 0xe, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0x20, 0xef, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xfd, 0xe, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf9, + + /* U+039B "Λ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xfe, 0xef, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf9, 0xaf, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xf4, 0x5f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf0, 0xf, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xa0, 0xa, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x40, 0x4, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xfe, 0x0, 0x0, 0xef, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf8, 0x0, 0x0, 0x9f, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf2, + 0x0, 0x0, 0x3f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xc0, 0x0, 0x0, + 0xd, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x60, 0x0, 0x0, 0x8, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x10, 0x0, 0x0, 0x2, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0x10, 0x0, 0x0, 0x7, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x60, 0x0, 0x0, 0xd, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xd0, 0x0, 0x0, 0x3f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf3, 0x0, + 0x0, 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf9, 0x0, 0x0, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0x0, 0x6, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x50, 0xc, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xc0, + 0x3f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf2, 0x9f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf8, + + /* U+039C "Μ" */ + 0xdf, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xdd, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xfd, 0xdf, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xdd, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xfd, 0xdf, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0xdd, 0xff, 0xfa, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xfc, 0xff, 0xfd, 0xdf, + 0xff, 0x4f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0x7f, 0xff, 0xdd, 0xff, 0xf0, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xf1, 0xff, 0xfd, 0xdf, 0xff, 0xa, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfc, + 0xf, 0xff, 0xdd, 0xff, 0xf0, 0x4f, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x60, 0xff, + 0xfd, 0xdf, 0xff, 0x0, 0xef, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xf1, 0xf, 0xff, 0xdd, + 0xff, 0xf0, 0x9, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xfb, 0x0, 0xff, 0xfd, 0xdf, 0xff, + 0x0, 0x4f, 0xff, 0x50, 0x0, 0x0, 0x0, 0xd, + 0xff, 0x50, 0xf, 0xff, 0xdd, 0xff, 0xf0, 0x0, + 0xef, 0xfa, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf0, + 0x0, 0xff, 0xfd, 0xdf, 0xff, 0x0, 0x9, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x8f, 0xfa, 0x0, 0xf, + 0xff, 0xdd, 0xff, 0xf0, 0x0, 0x3f, 0xff, 0x50, + 0x0, 0x0, 0xd, 0xff, 0x50, 0x0, 0xff, 0xfd, + 0xdf, 0xff, 0x0, 0x0, 0xef, 0xfa, 0x0, 0x0, + 0x3, 0xff, 0xf0, 0x0, 0xf, 0xff, 0xdd, 0xff, + 0xf0, 0x0, 0x9, 0xff, 0xf0, 0x0, 0x0, 0x8f, + 0xfa, 0x0, 0x0, 0xff, 0xfd, 0xdf, 0xff, 0x0, + 0x0, 0x3f, 0xff, 0x50, 0x0, 0xe, 0xff, 0x40, + 0x0, 0xf, 0xff, 0xdd, 0xff, 0xf0, 0x0, 0x0, + 0xef, 0xfa, 0x0, 0x3, 0xff, 0xe0, 0x0, 0x0, + 0xff, 0xfd, 0xdf, 0xff, 0x0, 0x0, 0x8, 0xff, + 0xf0, 0x0, 0x9f, 0xf9, 0x0, 0x0, 0xf, 0xff, + 0xdd, 0xff, 0xf0, 0x0, 0x0, 0x3f, 0xff, 0x50, + 0xe, 0xff, 0x30, 0x0, 0x0, 0xff, 0xfd, 0xdf, + 0xff, 0x0, 0x0, 0x0, 0xdf, 0xfa, 0x4, 0xff, + 0xe0, 0x0, 0x0, 0xf, 0xff, 0xdd, 0xff, 0xf0, + 0x0, 0x0, 0x8, 0xff, 0xf0, 0x9f, 0xf8, 0x0, + 0x0, 0x0, 0xff, 0xfd, 0xdf, 0xff, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0x5e, 0xff, 0x30, 0x0, 0x0, + 0xf, 0xff, 0xdd, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0xdf, 0xfd, 0xff, 0xd0, 0x0, 0x0, 0x0, 0xff, + 0xfd, 0xdf, 0xff, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0xf, 0xff, 0xdd, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0xff, 0xfd, 0xdf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xdd, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xfd, + + /* U+039D "Ν" */ + 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xa, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xf0, 0xaf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xa, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xf0, 0xaf, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xa, 0xff, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xf0, 0xaf, 0xff, 0xef, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xa, + 0xff, 0xf4, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf0, 0xaf, 0xff, 0x27, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xa, 0xff, 0xf2, 0xc, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xf0, 0xaf, 0xff, 0x20, + 0x2f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xa, 0xff, 0xf2, 0x0, 0x7f, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf0, 0xaf, 0xff, + 0x20, 0x0, 0xcf, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xa, 0xff, 0xf2, 0x0, 0x2, 0xff, + 0xff, 0x70, 0x0, 0x0, 0xd, 0xff, 0xf0, 0xaf, + 0xff, 0x20, 0x0, 0x7, 0xff, 0xff, 0x20, 0x0, + 0x0, 0xdf, 0xff, 0xa, 0xff, 0xf2, 0x0, 0x0, + 0xc, 0xff, 0xfc, 0x0, 0x0, 0xd, 0xff, 0xf0, + 0xaf, 0xff, 0x20, 0x0, 0x0, 0x2f, 0xff, 0xf7, + 0x0, 0x0, 0xdf, 0xff, 0xa, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xf2, 0x0, 0xd, 0xff, + 0xf0, 0xaf, 0xff, 0x20, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xc0, 0x0, 0xdf, 0xff, 0xa, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x70, 0xd, + 0xff, 0xf0, 0xaf, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0x20, 0xdf, 0xff, 0xa, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, + 0xd, 0xff, 0xf0, 0xaf, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xf7, 0xdf, 0xff, 0xa, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xfe, 0xff, 0xf0, 0xaf, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, + 0xa, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0xf0, 0xaf, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xff, 0xa, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xf0, 0xaf, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xa, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf0, + + /* U+039E "Ξ" */ + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x80, 0x3f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x80, 0x18, 0x88, 0x88, 0x88, + 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x27, 0x77, 0x77, + 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x40, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x68, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, + 0x88, 0x88, 0x88, 0x80, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf1, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + + /* U+039F "Ο" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x36, 0x77, + 0x75, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xa3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xb2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xf9, 0x41, 0x0, 0x1, 0x6b, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfb, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x4d, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x5, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xcf, 0xff, 0xe1, + 0x0, 0x0, 0xe, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xfa, 0x0, + 0x0, 0x7f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x20, 0x0, + 0xef, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x90, 0x3, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xe0, 0x7, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf2, 0xb, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf6, 0xd, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xf8, 0xe, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf9, 0xf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfa, + 0xf, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfa, 0xf, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf9, 0xe, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xf8, 0xb, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf6, 0x8, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf2, 0x3, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xe0, 0x0, 0xef, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x90, 0x0, 0x7f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x20, + 0x0, 0xe, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xfa, 0x0, 0x0, + 0x6, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xcf, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xfa, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x3d, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xf8, 0x30, 0x0, 0x1, 0x5b, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xff, 0xee, 0xff, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xa3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x36, + 0x77, 0x75, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A0 "Π" */ + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xaf, 0xff, 0xa8, 0x88, + 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + + /* U+03A1 "Ρ" */ + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdc, + 0x96, 0x10, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0xcf, 0xff, 0x98, 0x88, + 0x88, 0x88, 0x88, 0xac, 0xff, 0xff, 0xf9, 0x0, + 0xcf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2c, 0xff, 0xff, 0x30, 0xcf, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xa0, + 0xcf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xe0, 0xcf, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf1, + 0xcf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf2, 0xcf, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf2, + 0xcf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf0, 0xcf, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xc0, + 0xcf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x70, 0xcf, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6e, 0xff, 0xff, 0x10, + 0xcf, 0xff, 0x98, 0x88, 0x88, 0x88, 0x89, 0xbf, + 0xff, 0xff, 0xf5, 0x0, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd4, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0xdb, 0x73, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A3 "Σ" */ + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x70, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x70, 0xff, 0xff, 0xc8, 0x88, 0x88, 0x88, 0x88, + 0x88, 0x88, 0x88, 0x30, 0x7f, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xe2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xfd, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xdf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2e, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2e, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xc8, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, + 0x82, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf5, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf5, + + /* U+03A4 "Τ" */ + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb1, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfb, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x88, 0x88, + 0x88, 0x88, 0x89, 0xff, 0xfe, 0x88, 0x88, 0x88, + 0x88, 0x85, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A5 "Υ" */ + 0x8f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf5, 0xd, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xa0, 0x3, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xfe, 0x10, 0x0, 0x8f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf4, 0x0, + 0x0, 0xd, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x90, 0x0, 0x0, 0x3, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x8, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf3, 0x0, 0x0, 0x3f, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xfc, 0x0, 0x0, 0xdf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x60, 0x7, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xe1, 0x1f, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xf9, 0xaf, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+03A6 "Φ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xaa, + 0xa8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x38, 0xbd, 0xff, 0xff, 0xff, 0xfe, + 0xc9, 0x51, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x20, 0x0, 0x0, 0x0, 0x0, 0x1b, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x1d, 0xff, + 0xff, 0xfb, 0x75, 0x7f, 0xff, 0xd5, 0x69, 0xdf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0xd, 0xff, 0xff, + 0x81, 0x0, 0x3, 0xff, 0xfc, 0x0, 0x0, 0x4d, + 0xff, 0xff, 0x60, 0x0, 0x8, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0x20, 0x1, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x3, 0xff, 0xfc, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xfa, 0x0, 0x8f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf1, 0xd, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x50, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xf9, 0x2f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xa3, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfb, + 0x2f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xa1, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf9, 0xe, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x60, 0x9f, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf1, 0x4, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x3, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xfc, 0x0, 0xb, 0xff, + 0xfe, 0x20, 0x0, 0x0, 0x3f, 0xff, 0xc0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0x30, 0x0, 0x2e, 0xff, + 0xff, 0x60, 0x0, 0x3, 0xff, 0xfc, 0x0, 0x0, + 0x9, 0xff, 0xff, 0x90, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xd7, 0x31, 0x4f, 0xff, 0xc0, 0x25, 0x9f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x3d, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x7b, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x93, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x12, 0x6f, 0xff, 0xd3, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A7 "Χ" */ + 0x2, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0x80, 0x0, 0x5f, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xfc, 0x0, 0x0, 0xa, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0xef, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xd0, 0x0, 0x0, 0x5, 0xff, 0xfe, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf9, + 0x0, 0x0, 0x2f, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x50, 0x0, + 0xdf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xe1, 0x9, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xfa, 0x4f, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xef, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xfd, 0xdf, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xf3, 0x4f, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0x80, 0x9, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xfc, 0x0, 0x0, + 0xdf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xf2, 0x0, 0x0, 0x3f, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x7, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x3f, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xf3, 0x0, 0x1, 0xef, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfe, 0x10, + 0xb, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xa0, 0x7f, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf6, + + /* U+03A8 "Ψ" */ + 0x6f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x76, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf7, 0x6f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x76, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xf7, 0x6f, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0x76, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xf7, 0x6f, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x76, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xf7, 0x6f, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0x75, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf6, 0x4f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x53, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x80, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf4, 0xf, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x0, 0xbf, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xc0, 0x5, 0xff, 0xff, 0x20, 0x0, 0x0, 0x7, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf7, + 0x0, 0xe, 0xff, 0xfd, 0x20, 0x0, 0x0, 0x7f, + 0xff, 0x80, 0x0, 0x0, 0x2d, 0xff, 0xfe, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0x81, 0x0, 0x7, 0xff, + 0xf8, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xfc, 0x86, 0x9f, 0xff, + 0xb7, 0x8b, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x3a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfa, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x69, 0xcd, 0xff, 0xff, 0xff, 0xfe, + 0xc9, 0x61, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+03A9 "Ω" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x56, 0x77, + 0x64, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x8e, 0xff, 0xff, 0xff, 0xff, + 0xc6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1c, 0xff, + 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xe8, + 0x20, 0x0, 0x15, 0xbf, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xa1, 0x0, 0x0, + 0x0, 0x0, 0x5e, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x7, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xfd, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xf7, 0x0, 0x0, 0x7f, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xe0, 0x0, 0xd, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0x40, 0x2, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf9, 0x0, + 0x5f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xc0, 0x8, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x0, 0x9f, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xf0, 0xa, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0x10, 0xaf, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf0, + 0x9, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x7f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xd0, 0x4, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xfa, 0x0, 0xf, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x60, 0x0, 0xaf, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf1, + 0x0, 0x3, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xf9, 0x0, 0x0, + 0xb, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x20, 0x0, 0x0, 0x2f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x4e, 0xff, 0xd1, 0x0, 0x0, 0x0, + 0x88, 0x88, 0x88, 0xdf, 0xff, 0xe5, 0x0, 0x1, + 0xbf, 0xff, 0xf9, 0x88, 0x88, 0x83, 0xf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x60, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf6, 0xf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x60, + + /* U+03AA "Ϊ" */ + 0xf, 0xff, 0xd0, 0x0, 0x6f, 0xff, 0x70, 0xff, + 0xfd, 0x0, 0x6, 0xff, 0xf7, 0xf, 0xff, 0xd0, + 0x0, 0x6f, 0xff, 0x70, 0xff, 0xfd, 0x0, 0x6, + 0xff, 0xf7, 0x2, 0x22, 0x20, 0x0, 0x2, 0x22, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfc, + 0x0, 0x0, + + /* U+03AB "Ϋ" */ + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x0, 0x3, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x0, 0x3, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x0, 0x3, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x0, 0x3, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x22, 0x22, 0x0, 0x0, + 0x22, 0x21, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf5, 0xd, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xa0, + 0x3, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xfe, 0x10, 0x0, 0x8f, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xf4, 0x0, 0x0, 0xd, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x90, 0x0, 0x0, 0x3, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x8, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf3, + 0x0, 0x0, 0x3f, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xfc, 0x0, 0x0, + 0xdf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x60, 0x7, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xe1, 0x1f, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xf9, 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03AC "ά" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3a, 0xa9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x7c, 0xef, + 0xfd, 0x92, 0x0, 0x3, 0xff, 0xf8, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0x70, 0x8, 0xff, + 0xf4, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0xc, 0xff, 0xf0, 0x0, 0x7f, 0xff, 0xfc, + 0x51, 0x2, 0x8f, 0xff, 0x7f, 0xff, 0xb0, 0x2, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x2, 0xef, 0xff, + 0xff, 0x70, 0x8, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0x30, 0xe, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x0, + 0x2f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xfc, 0x0, 0x5f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf8, 0x0, 0x6f, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf5, + 0x0, 0x7f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf2, 0x0, 0x7f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf2, 0x0, 0x6f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xf5, 0x0, 0x5f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf8, 0x0, 0x1f, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xfb, 0x0, + 0xd, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xfe, 0x0, 0x7, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0x20, 0x1, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x6f, 0xff, 0xfb, 0x40, 0x3, 0x9f, + 0xff, 0x5f, 0xff, 0xa0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0xc, 0xff, 0xe0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0x90, 0x7, + 0xff, 0xf2, 0x0, 0x0, 0x1, 0x7c, 0xef, 0xfd, + 0x93, 0x0, 0x2, 0xff, 0xf8, + + /* U+03AD "έ" */ + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xaa, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x7b, 0xef, 0xfd, 0xa5, 0x0, 0x0, + 0x0, 0x4e, 0xff, 0xff, 0xff, 0xff, 0xe5, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, + 0xc, 0xff, 0xfb, 0x42, 0x37, 0xdf, 0xfe, 0x30, + 0x2f, 0xff, 0xa0, 0x0, 0x0, 0x5, 0xb1, 0x0, + 0x5f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xfd, 0x62, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x3, 0xef, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xfc, 0x51, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0x0, 0x0, 0x0, 0x0, 0x25, 0x0, + 0xaf, 0xff, 0x80, 0x0, 0x0, 0x4, 0xef, 0x80, + 0x3f, 0xff, 0xfa, 0x30, 0x14, 0xaf, 0xff, 0xf7, + 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xe5, 0x0, + 0x0, 0x2, 0x9c, 0xef, 0xed, 0x95, 0x0, 0x0, + + /* U+03AE "ή" */ + 0x0, 0x0, 0x0, 0x0, 0x1, 0xaa, 0xaa, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf2, + 0x0, 0x39, 0xde, 0xfe, 0xb6, 0x0, 0x0, 0x2f, + 0xff, 0x21, 0xbf, 0xff, 0xff, 0xff, 0xfd, 0x30, + 0x2, 0xff, 0xf3, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x20, 0x2f, 0xff, 0xdf, 0xfc, 0x63, 0x24, + 0x9f, 0xff, 0xfc, 0x2, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xf1, 0x2f, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x52, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf7, + 0x2f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0x82, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf8, 0x2f, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x82, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf8, 0x2f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x82, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xf8, 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x82, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xf8, 0x2f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x82, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf8, 0x2f, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x82, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf8, 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0x82, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xf8, 0x2f, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x80, + + /* U+03AF "ί" */ + 0x0, 0x2a, 0xaa, 0xa5, 0x0, 0xaf, 0xff, 0xc0, + 0x2, 0xff, 0xfe, 0x10, 0x9, 0xff, 0xf4, 0x0, + 0x1f, 0xff, 0x70, 0x0, 0x9f, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x80, 0x0, + 0x3f, 0xff, 0x80, 0x0, 0x3f, 0xff, 0x80, 0x0, + 0x3f, 0xff, 0x80, 0x0, 0x3f, 0xff, 0x80, 0x0, + 0x3f, 0xff, 0x80, 0x0, 0x3f, 0xff, 0x80, 0x0, + 0x3f, 0xff, 0x80, 0x0, 0x3f, 0xff, 0x80, 0x0, + 0x3f, 0xff, 0x80, 0x0, 0x3f, 0xff, 0x80, 0x0, + 0x3f, 0xff, 0x80, 0x0, 0x3f, 0xff, 0x80, 0x0, + 0x3f, 0xff, 0x80, 0x0, 0x3f, 0xff, 0x80, 0x0, + 0x3f, 0xff, 0x80, 0x0, 0x3f, 0xff, 0x80, 0x0, + 0x3f, 0xff, 0x80, 0x0, 0x3f, 0xff, 0x80, 0x0, + 0x3f, 0xff, 0x80, 0x0, 0x3f, 0xff, 0x80, 0x0, + 0x3f, 0xff, 0x80, 0x0, + + /* U+03B0 "ΰ" */ + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf9, 0x0, 0x8f, + 0xfb, 0x9, 0xff, 0xf0, 0x0, 0xf, 0xff, 0x90, + 0xe, 0xfe, 0x10, 0x9f, 0xff, 0x0, 0x0, 0xff, + 0xf9, 0x6, 0xff, 0x40, 0x9, 0xff, 0xf0, 0x0, + 0xd, 0xee, 0x80, 0xce, 0x90, 0x0, 0x8e, 0xed, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf3, 0x3f, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0x33, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xf3, 0x3f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x33, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf3, 0x3f, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x33, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf3, + 0x3f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x33, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xf3, 0x3f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x33, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf3, 0x3f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x33, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf3, 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x21, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf1, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xfe, 0x0, 0xcf, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xa0, 0x6, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x2e, 0xff, 0xf4, + 0x0, 0xd, 0xff, 0xfe, 0x71, 0x2, 0x7e, 0xff, + 0xfb, 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x10, 0x0, 0x0, 0x1b, 0xff, 0xff, + 0xff, 0xff, 0xfa, 0x10, 0x0, 0x0, 0x0, 0x3, + 0x9d, 0xff, 0xec, 0x83, 0x0, 0x0, 0x0, + + /* U+03B1 "α" */ + 0x0, 0x0, 0x1, 0x7c, 0xef, 0xfd, 0x92, 0x0, + 0x3, 0xff, 0xf8, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xff, 0xff, 0x70, 0x8, 0xff, 0xf4, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0xc, 0xff, + 0xf0, 0x0, 0x7f, 0xff, 0xfc, 0x51, 0x2, 0x8f, + 0xff, 0x7f, 0xff, 0xb0, 0x2, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0x70, 0x8, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0x30, 0xe, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0x0, 0x2f, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfc, 0x0, + 0x5f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf8, 0x0, 0x6f, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xf5, 0x0, 0x7f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf2, + 0x0, 0x7f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf2, 0x0, 0x6f, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xf5, 0x0, 0x5f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xf8, 0x0, 0x1f, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xfb, 0x0, 0xd, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xfe, 0x0, + 0x7, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0x20, 0x1, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0x60, 0x0, 0x6f, + 0xff, 0xfb, 0x40, 0x3, 0x9f, 0xff, 0x5f, 0xff, + 0xa0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0xc, 0xff, 0xe0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xff, 0xff, 0x90, 0x7, 0xff, 0xf2, 0x0, + 0x0, 0x1, 0x7c, 0xef, 0xfd, 0x93, 0x0, 0x2, + 0xff, 0xf8, + + /* U+03B2 "β" */ + 0x0, 0x0, 0x0, 0x2, 0x57, 0x76, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7d, 0xff, 0xff, + 0xff, 0xe7, 0x0, 0x0, 0x0, 0x0, 0x3, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x10, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xfb, 0x88, 0xbf, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x91, 0x0, 0x0, + 0x2c, 0xff, 0xf7, 0x0, 0x0, 0x6f, 0xff, 0x80, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xe0, 0x0, 0xb, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x40, 0x0, 0xef, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xf6, 0x0, 0xf, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x60, 0x1, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf4, + 0x0, 0x1f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x0, 0x2, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0x70, 0x0, 0x2f, 0xff, + 0x80, 0x0, 0x0, 0x1, 0x8f, 0xff, 0xa0, 0x0, + 0x2, 0xff, 0xf8, 0x0, 0x2a, 0xbe, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x2f, 0xff, 0x80, 0x3, 0xff, + 0xff, 0xfb, 0x30, 0x0, 0x0, 0x2, 0xff, 0xf8, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0xd5, 0x0, 0x0, + 0x2f, 0xff, 0x80, 0x0, 0x0, 0x24, 0x9f, 0xff, + 0xfb, 0x0, 0x2, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x1c, 0xff, 0xfa, 0x0, 0x2f, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf5, 0x2, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xc0, 0x2f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0x2, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf2, 0x2f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x32, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf2, 0x2f, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xfe, 0x2, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xa0, 0x2f, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xf2, 0x2, 0xff, 0xff, 0xff, 0xb2, + 0x0, 0x0, 0x4e, 0xff, 0xf8, 0x0, 0x2f, 0xff, + 0x9c, 0xff, 0xfd, 0xbb, 0xef, 0xff, 0xfb, 0x0, + 0x2, 0xff, 0xf8, 0x9, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x2f, 0xff, 0x80, 0x3, 0x8d, + 0xef, 0xec, 0x82, 0x0, 0x0, 0x2, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+03B3 "γ" */ + 0x4f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x40, 0xef, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xe0, 0x8, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf8, 0x0, + 0x2f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0x20, 0x0, 0xcf, 0xff, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xc0, 0x0, 0x7, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf6, 0x0, 0x0, + 0x1f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x10, 0x0, 0x0, 0xbf, 0xff, 0x10, 0x0, 0x0, + 0xf, 0xff, 0xa0, 0x0, 0x0, 0x5, 0xff, 0xf6, + 0x0, 0x0, 0x6, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xc0, 0x0, 0x0, 0xbf, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0x20, 0x0, 0x1f, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf7, + 0x0, 0x7, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xd0, 0x0, 0xdf, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0x30, 0x3f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf8, + 0x9, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xe0, 0xef, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x9f, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, + + /* U+03B4 "δ" */ + 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x6f, 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1b, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xfb, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xef, 0xfe, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6b, + 0xef, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xef, 0xff, 0xff, 0xff, 0xff, 0xd2, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xfd, 0xcd, 0xff, + 0xff, 0xe3, 0x0, 0x0, 0x6, 0xff, 0xff, 0xa2, + 0x0, 0x0, 0x7f, 0xff, 0xf3, 0x0, 0x1, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x3e, 0xff, 0xe1, + 0x0, 0x8f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xa0, 0xe, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x22, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf7, + 0x5f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xa6, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xfd, 0x7f, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xe7, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xfd, 0x6f, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xc4, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfb, 0xf, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x70, 0xbf, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf3, 0x4, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xfc, 0x0, 0xc, + 0xff, 0xfc, 0x10, 0x0, 0x0, 0x5, 0xff, 0xff, + 0x40, 0x0, 0x2f, 0xff, 0xfe, 0x72, 0x1, 0x4b, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x2c, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x4, 0x9d, 0xef, 0xed, 0xa5, + 0x0, 0x0, 0x0, + + /* U+03B5 "ε" */ + 0x0, 0x1, 0x7b, 0xef, 0xfd, 0xa5, 0x0, 0x0, + 0x0, 0x4e, 0xff, 0xff, 0xff, 0xff, 0xe5, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, + 0xc, 0xff, 0xfb, 0x42, 0x37, 0xdf, 0xfe, 0x30, + 0x2f, 0xff, 0xa0, 0x0, 0x0, 0x5, 0xb1, 0x0, + 0x5f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xfd, 0x62, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x3, 0xef, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xfc, 0x51, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0x0, 0x0, 0x0, 0x0, 0x25, 0x0, + 0xaf, 0xff, 0x80, 0x0, 0x0, 0x4, 0xef, 0x80, + 0x3f, 0xff, 0xfa, 0x30, 0x14, 0xaf, 0xff, 0xf7, + 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xe5, 0x0, + 0x0, 0x2, 0x9c, 0xef, 0xed, 0x95, 0x0, 0x0, + + /* U+03B6 "ζ" */ + 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf2, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf2, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1c, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xdf, 0xfd, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1d, 0xff, 0xd1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0x83, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xfe, 0xca, + 0x73, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x5a, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x14, 0xcf, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x38, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xda, 0x60, 0x0, 0x0, + + /* U+03B7 "η" */ + 0x2f, 0xff, 0x20, 0x3, 0x9d, 0xef, 0xeb, 0x60, + 0x0, 0x2, 0xff, 0xf2, 0x1b, 0xff, 0xff, 0xff, + 0xff, 0xd3, 0x0, 0x2f, 0xff, 0x3d, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf2, 0x2, 0xff, 0xfd, 0xff, + 0xc6, 0x32, 0x49, 0xff, 0xff, 0xc0, 0x2f, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x4, 0xff, 0xff, 0x12, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf5, 0x2f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x72, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf8, 0x2f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x82, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf8, 0x2f, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x82, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf8, 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0x82, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xf8, 0x2f, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x82, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf8, + 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0x82, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf8, 0x2f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x82, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf8, 0x2f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x82, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xf8, + + /* U+03B8 "θ" */ + 0x0, 0x0, 0x0, 0x0, 0x35, 0x76, 0x41, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xef, 0xff, + 0xff, 0xfb, 0x30, 0x0, 0x0, 0x0, 0x0, 0x2d, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xff, 0xa8, 0x9d, 0xff, 0xff, + 0x50, 0x0, 0x0, 0xb, 0xff, 0xfa, 0x0, 0x0, + 0x6, 0xff, 0xff, 0x20, 0x0, 0x4, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xfa, 0x0, 0x0, + 0xbf, 0xff, 0x20, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf1, 0x0, 0xf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x60, 0x5, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xfb, 0x0, 0x8f, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf0, 0xb, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0x10, 0xdf, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xf3, 0xf, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x50, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf6, 0xf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x71, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x70, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xf6, 0xf, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x60, + 0xef, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xf5, 0xc, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x20, 0xaf, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf0, 0x7, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xfd, 0x0, 0x3f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0x90, 0x0, 0xef, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf4, 0x0, 0x8, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfd, + 0x0, 0x0, 0x1f, 0xff, 0xf4, 0x0, 0x0, 0x1, + 0xcf, 0xff, 0x60, 0x0, 0x0, 0x6f, 0xff, 0xf8, + 0x20, 0x15, 0xdf, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, + 0xa1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x17, 0xce, + 0xfe, 0xd9, 0x30, 0x0, 0x0, 0x0, + + /* U+03B9 "ι" */ + 0x3f, 0xff, 0x83, 0xff, 0xf8, 0x3f, 0xff, 0x83, + 0xff, 0xf8, 0x3f, 0xff, 0x83, 0xff, 0xf8, 0x3f, + 0xff, 0x83, 0xff, 0xf8, 0x3f, 0xff, 0x83, 0xff, + 0xf8, 0x3f, 0xff, 0x83, 0xff, 0xf8, 0x3f, 0xff, + 0x83, 0xff, 0xf8, 0x3f, 0xff, 0x83, 0xff, 0xf8, + 0x3f, 0xff, 0x83, 0xff, 0xf8, 0x3f, 0xff, 0x83, + 0xff, 0xf8, 0x3f, 0xff, 0x83, 0xff, 0xf8, + + /* U+03BA "κ" */ + 0x4f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xf9, 0x4, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf8, 0x0, 0x4f, 0xff, 0x60, 0x0, 0x0, + 0x5f, 0xff, 0xf7, 0x0, 0x4, 0xff, 0xf6, 0x0, + 0x0, 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x4f, 0xff, + 0x60, 0x0, 0x5f, 0xff, 0xf5, 0x0, 0x0, 0x4, + 0xff, 0xf6, 0x0, 0x5f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x60, 0x6f, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xf6, 0x6f, 0xff, 0xe3, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xcf, 0xff, + 0xe2, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xef, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xc1, 0x8f, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf6, 0x0, 0xbf, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x60, + 0x0, 0xdf, 0xff, 0xc0, 0x0, 0x0, 0x4, 0xff, + 0xf6, 0x0, 0x2, 0xef, 0xff, 0xa0, 0x0, 0x0, + 0x4f, 0xff, 0x60, 0x0, 0x4, 0xff, 0xff, 0x70, + 0x0, 0x4, 0xff, 0xf6, 0x0, 0x0, 0x6, 0xff, + 0xff, 0x40, 0x0, 0x4f, 0xff, 0x60, 0x0, 0x0, + 0x9, 0xff, 0xff, 0x20, 0x4, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xfd, 0x10, 0x4f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xfb, 0x4, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf9, + + /* U+03BB "λ" */ + 0x0, 0x0, 0x7, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xd0, 0xef, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xf8, 0x8, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x20, + 0x2f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xb0, 0x0, 0xcf, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xf5, 0x0, 0x6, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x0, 0x0, + 0xf, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x90, 0x0, 0x0, 0xaf, 0xff, 0x40, 0x0, 0x0, + 0xa, 0xff, 0xf3, 0x0, 0x0, 0x4, 0xff, 0xfa, + 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xf1, 0x0, 0x0, 0x6f, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0x60, 0x0, 0xc, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfc, + 0x0, 0x2, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf2, 0x0, 0x8f, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x80, 0xe, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfe, + 0x5, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf4, + + /* U+03BC "μ" */ + 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0x72, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf7, 0x2f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x72, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf7, 0x2f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x72, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xf7, 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x72, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xf7, 0x2f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x72, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf7, 0x2f, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x72, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf7, 0x2f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0x72, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xf7, 0x2f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x72, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf7, + 0x2f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0x72, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xf7, 0x2f, 0xff, 0xff, 0xd4, 0x0, + 0x2, 0xbf, 0xff, 0xff, 0x72, 0xff, 0xff, 0xff, + 0xfe, 0xde, 0xff, 0xff, 0xef, 0xf7, 0x2f, 0xff, + 0x9d, 0xff, 0xff, 0xff, 0xff, 0x5d, 0xff, 0x72, + 0xff, 0xf8, 0x1a, 0xff, 0xff, 0xfd, 0x40, 0xdf, + 0xf7, 0x2f, 0xff, 0x80, 0x1, 0x57, 0x63, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03BD "ν" */ + 0x4f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x50, 0xef, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xe0, 0x8, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf9, 0x0, + 0x2f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0x30, 0x0, 0xcf, 0xff, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xd0, 0x0, 0x6, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf7, 0x0, 0x0, + 0xf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x10, 0x0, 0x0, 0xaf, 0xff, 0x10, 0x0, 0x0, + 0xf, 0xff, 0xb0, 0x0, 0x0, 0x4, 0xff, 0xf7, + 0x0, 0x0, 0x5, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xc0, 0x0, 0x0, 0xbf, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0x20, 0x0, 0x1f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf8, + 0x0, 0x6, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xd0, 0x0, 0xcf, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x30, 0x2f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf8, + 0x8, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xd0, 0xdf, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x5f, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfe, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + + /* U+03BE "ξ" */ + 0x0, 0x0, 0x0, 0x39, 0xce, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x3c, 0xff, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x2f, 0xff, 0xfb, 0x63, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xf9, 0x42, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x29, 0xef, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x5e, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x1b, + 0xff, 0xff, 0xa5, 0x21, 0x0, 0x0, 0x0, 0x1, + 0xdf, 0xff, 0x91, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfd, 0x84, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xff, + 0xff, 0xc8, 0x10, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x2, + 0x8d, 0xff, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x13, 0x6a, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x7b, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xfe, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xea, 0x60, 0x0, 0x0, + + /* U+03BF "ο" */ + 0x0, 0x0, 0x0, 0x38, 0xce, 0xfe, 0xda, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xe6, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xd6, 0x20, 0x14, 0xaf, 0xff, + 0xf8, 0x0, 0x0, 0xef, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf4, 0x0, 0x7f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xc0, 0xd, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x31, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xf7, 0x5f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xb6, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xfc, 0x7f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xd7, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xfd, 0x6f, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xc5, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xfa, 0x1f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x60, 0xdf, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf3, + 0x7, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xfc, 0x0, 0xe, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0x40, 0x0, 0x4f, 0xff, + 0xfd, 0x61, 0x1, 0x4a, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x2b, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x60, 0x0, 0x0, 0x0, 0x0, 0x3, + 0x8c, 0xef, 0xfd, 0xa5, 0x0, 0x0, 0x0, + + /* U+03C0 "π" */ + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x11, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf1, 0x1f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x5, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x10, 0x0, 0x0, + + /* U+03C1 "ρ" */ + 0x0, 0x0, 0x0, 0x6a, 0xdf, 0xfe, 0xc7, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xa1, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd2, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xc5, 0x10, 0x26, 0xef, 0xff, + 0xe1, 0x0, 0x0, 0xdf, 0xff, 0x80, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xb0, 0x0, 0x4f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x30, 0xa, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xfa, 0x0, 0xdf, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf0, 0xf, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x32, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf4, 0x3f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0x64, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf6, 0x5f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0x45, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf3, 0x5f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x5, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xb0, + 0x5f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf4, 0x5, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfc, 0x0, 0x5f, 0xff, 0xff, + 0xfb, 0x41, 0x1, 0x6d, 0xff, 0xff, 0x20, 0x5, + 0xff, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x30, 0x0, 0x5f, 0xff, 0x66, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x20, 0x0, 0x5, 0xff, 0xf6, 0x1, + 0x7b, 0xef, 0xed, 0x94, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+03C2 "ς" */ + 0x0, 0x0, 0x0, 0x0, 0x16, 0xad, 0xef, 0xfe, + 0xc9, 0x40, 0x0, 0x0, 0x2, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, 0xa, 0xff, + 0xff, 0xb6, 0x21, 0x1, 0x26, 0x90, 0x0, 0x8, + 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xfd, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xd4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xfc, 0x61, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xef, 0xff, 0xff, + 0xfc, 0x83, 0x0, 0x0, 0x0, 0x0, 0x1, 0x9f, + 0xff, 0xff, 0xff, 0xfd, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x17, 0xcf, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0x8d, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xcf, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x3, 0x76, 0x7a, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xff, 0xe4, 0x0, 0x0, 0x0, 0x0, 0x1, 0xde, + 0xff, 0xea, 0x50, 0x0, 0x0, + + /* U+03C3 "σ" */ + 0x0, 0x0, 0x0, 0x38, 0xce, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x3c, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x0, 0x5f, 0xff, 0xfd, + 0x51, 0x1, 0x4a, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x1, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xf4, 0x0, 0x0, 0x9, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xfc, 0x0, 0x0, + 0xf, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x30, 0x0, 0x3f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x60, 0x0, + 0x6f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xa0, 0x0, 0x8f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xb0, 0x0, + 0x9f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xc0, 0x0, 0x9f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xb0, 0x0, + 0x8f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xa0, 0x0, 0x6f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x90, 0x0, + 0x3f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x50, 0x0, 0xf, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x10, 0x0, + 0x8, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xfb, 0x0, 0x0, 0x1, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xfc, 0x51, 0x1, 0x4a, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3c, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x49, + 0xde, 0xfe, 0xd9, 0x40, 0x0, 0x0, 0x0, 0x0, + + /* U+03C4 "τ" */ + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x60, 0x0, 0x0, + + /* U+03C5 "υ" */ + 0x3f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x33, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xf3, 0x3f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x33, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf3, 0x3f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x33, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf3, 0x3f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x33, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf3, 0x3f, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0x33, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf3, 0x3f, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0x33, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xf3, 0x3f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x32, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf2, 0x1f, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x10, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xe0, + 0xc, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xfa, 0x0, 0x6f, 0xff, 0xe1, 0x0, 0x0, 0x2, + 0xef, 0xff, 0x40, 0x0, 0xdf, 0xff, 0xe7, 0x10, + 0x27, 0xef, 0xff, 0xb0, 0x0, 0x2, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x1, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xa1, 0x0, 0x0, + 0x0, 0x0, 0x39, 0xdf, 0xfe, 0xc8, 0x30, 0x0, + 0x0, + + /* U+03C6 "φ" */ + 0x0, 0x0, 0x0, 0x7c, 0xe1, 0x0, 0x2a, 0xef, + 0xfd, 0xa4, 0x0, 0x0, 0x0, 0x0, 0x4, 0xef, + 0xfe, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xfb, 0x10, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xa0, 0xa, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x10, 0x0, 0x4, 0xff, + 0xff, 0x92, 0x0, 0xef, 0xff, 0x71, 0x2b, 0xff, + 0xfa, 0x0, 0x0, 0xef, 0xff, 0x50, 0x0, 0xf, + 0xff, 0xd0, 0x0, 0xa, 0xff, 0xf4, 0x0, 0x7f, + 0xff, 0x70, 0x0, 0x0, 0xff, 0xfa, 0x0, 0x0, + 0xe, 0xff, 0xc0, 0xd, 0xff, 0xe0, 0x0, 0x0, + 0x1f, 0xff, 0x90, 0x0, 0x0, 0x8f, 0xff, 0x22, + 0xff, 0xfa, 0x0, 0x0, 0x1, 0xff, 0xf9, 0x0, + 0x0, 0x5, 0xff, 0xf7, 0x5f, 0xff, 0x60, 0x0, + 0x0, 0x1f, 0xff, 0x90, 0x0, 0x0, 0x2f, 0xff, + 0xa6, 0xff, 0xf5, 0x0, 0x0, 0x1, 0xff, 0xf9, + 0x0, 0x0, 0x1, 0xff, 0xfb, 0x7f, 0xff, 0x40, + 0x0, 0x0, 0x1f, 0xff, 0x90, 0x0, 0x0, 0x2f, + 0xff, 0xc7, 0xff, 0xf5, 0x0, 0x0, 0x1, 0xff, + 0xf9, 0x0, 0x0, 0x3, 0xff, 0xfb, 0x5f, 0xff, + 0x70, 0x0, 0x0, 0x1f, 0xff, 0x90, 0x0, 0x0, + 0x5f, 0xff, 0x93, 0xff, 0xfb, 0x0, 0x0, 0x1, + 0xff, 0xf9, 0x0, 0x0, 0x9, 0xff, 0xf5, 0xe, + 0xff, 0xf1, 0x0, 0x0, 0x1f, 0xff, 0x90, 0x0, + 0x0, 0xef, 0xff, 0x0, 0xaf, 0xff, 0x90, 0x0, + 0x1, 0xff, 0xf9, 0x0, 0x0, 0x7f, 0xff, 0x90, + 0x2, 0xff, 0xff, 0x40, 0x0, 0x1f, 0xff, 0x90, + 0x0, 0x3f, 0xff, 0xf2, 0x0, 0x9, 0xff, 0xfe, + 0x40, 0x1, 0xff, 0xf9, 0x0, 0x3e, 0xff, 0xf7, + 0x0, 0x0, 0xc, 0xff, 0xff, 0x92, 0x1f, 0xff, + 0x91, 0x8f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x1c, + 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xcf, 0xff, 0xff, 0xff, 0xfe, 0x91, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x15, + 0x7f, 0xff, 0xc4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03C7 "χ" */ + 0xc, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xe0, 0x3, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0x60, 0x0, 0xbf, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfd, + 0x0, 0x0, 0x3f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf5, 0x0, 0x0, 0xa, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xc0, 0x0, 0x0, + 0x2, 0xff, 0xfb, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x40, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x30, 0x0, + 0x2, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xb0, 0x0, 0xa, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf3, 0x0, 0x3f, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfb, + 0x0, 0xbf, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0x33, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xbb, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xee, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x77, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfe, 0x0, 0xef, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xf6, 0x0, 0x7f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xe0, 0x0, 0xe, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x60, 0x0, + 0x6, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0xef, 0xff, 0x10, 0x0, + 0x0, 0x9, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x90, 0x0, 0x0, 0x2f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xf2, 0x0, 0x0, 0xbf, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfb, + 0x0, 0x4, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x40, 0xd, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xd0, 0x6f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf6, + + /* U+03C8 "ψ" */ + 0x8f, 0xff, 0x20, 0x0, 0x0, 0xe, 0xff, 0xd0, + 0x0, 0x0, 0x4, 0xff, 0xf6, 0x8f, 0xff, 0x20, + 0x0, 0x0, 0xe, 0xff, 0xd0, 0x0, 0x0, 0x4, + 0xff, 0xf6, 0x8f, 0xff, 0x20, 0x0, 0x0, 0xe, + 0xff, 0xd0, 0x0, 0x0, 0x4, 0xff, 0xf6, 0x8f, + 0xff, 0x20, 0x0, 0x0, 0xe, 0xff, 0xd0, 0x0, + 0x0, 0x4, 0xff, 0xf6, 0x8f, 0xff, 0x20, 0x0, + 0x0, 0xe, 0xff, 0xd0, 0x0, 0x0, 0x4, 0xff, + 0xf6, 0x8f, 0xff, 0x20, 0x0, 0x0, 0xe, 0xff, + 0xd0, 0x0, 0x0, 0x4, 0xff, 0xf6, 0x8f, 0xff, + 0x20, 0x0, 0x0, 0xe, 0xff, 0xd0, 0x0, 0x0, + 0x4, 0xff, 0xf6, 0x8f, 0xff, 0x20, 0x0, 0x0, + 0xe, 0xff, 0xd0, 0x0, 0x0, 0x4, 0xff, 0xf6, + 0x8f, 0xff, 0x20, 0x0, 0x0, 0xe, 0xff, 0xd0, + 0x0, 0x0, 0x4, 0xff, 0xf6, 0x8f, 0xff, 0x20, + 0x0, 0x0, 0xe, 0xff, 0xd0, 0x0, 0x0, 0x4, + 0xff, 0xf6, 0x7f, 0xff, 0x20, 0x0, 0x0, 0xe, + 0xff, 0xd0, 0x0, 0x0, 0x4, 0xff, 0xf6, 0x7f, + 0xff, 0x20, 0x0, 0x0, 0xe, 0xff, 0xd0, 0x0, + 0x0, 0x4, 0xff, 0xf6, 0x7f, 0xff, 0x30, 0x0, + 0x0, 0xe, 0xff, 0xd0, 0x0, 0x0, 0x5, 0xff, + 0xf5, 0x6f, 0xff, 0x50, 0x0, 0x0, 0xe, 0xff, + 0xd0, 0x0, 0x0, 0x6, 0xff, 0xf4, 0x4f, 0xff, + 0x70, 0x0, 0x0, 0xe, 0xff, 0xd0, 0x0, 0x0, + 0x9, 0xff, 0xf2, 0x1f, 0xff, 0xc0, 0x0, 0x0, + 0xe, 0xff, 0xd0, 0x0, 0x0, 0xd, 0xff, 0xf0, + 0xc, 0xff, 0xf4, 0x0, 0x0, 0xe, 0xff, 0xd0, + 0x0, 0x0, 0x6f, 0xff, 0xb0, 0x4, 0xff, 0xff, + 0x40, 0x0, 0xe, 0xff, 0xd0, 0x0, 0x6, 0xff, + 0xff, 0x40, 0x0, 0x9f, 0xff, 0xfb, 0x62, 0x1e, + 0xff, 0xd1, 0x36, 0xcf, 0xff, 0xfa, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x6e, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x59, 0xce, 0xff, 0xff, + 0xff, 0xec, 0x95, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03C9 "ω" */ + 0x0, 0x3, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0xbf, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x80, 0x0, 0x0, + 0x3f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0x10, 0x0, 0xa, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xf6, 0x0, 0x0, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xc0, 0x0, 0x5f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x49, 0x99, 0x20, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x20, 0x9, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xf6, 0x0, 0xdf, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0x90, 0xf, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xfd, 0x1, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xe0, 0x2f, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x3, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x30, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf0, 0x2f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xfe, 0x1, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0x40, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xd0, 0xe, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfb, + 0x0, 0xaf, 0xff, 0x20, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x70, + 0x5, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf2, 0x0, + 0xe, 0xff, 0xf3, 0x0, 0x0, 0xc, 0xff, 0xaf, + 0xf9, 0x0, 0x0, 0x7, 0xff, 0xfc, 0x0, 0x0, + 0x6f, 0xff, 0xf5, 0x0, 0x2c, 0xff, 0xb0, 0xef, + 0xfa, 0x10, 0x7, 0xff, 0xff, 0x30, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xef, 0xff, 0xe1, 0x4, 0xff, + 0xff, 0xef, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xe2, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x3a, 0xdf, 0xfc, 0x70, 0x0, 0x0, 0x1, 0x8d, + 0xff, 0xd8, 0x20, 0x0, 0x0, + + /* U+03CA "ϊ" */ + 0x2f, 0xff, 0xb0, 0x0, 0x7f, 0xff, 0x62, 0xff, + 0xfb, 0x0, 0x7, 0xff, 0xf6, 0x2f, 0xff, 0xb0, + 0x0, 0x7f, 0xff, 0x62, 0xff, 0xfb, 0x0, 0x7, + 0xff, 0xf6, 0x2, 0x22, 0x10, 0x0, 0x12, 0x22, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf8, 0x0, 0x0, + + /* U+03CB "ϋ" */ + 0x0, 0x4, 0xff, 0xf9, 0x0, 0x9, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x90, 0x0, 0x9f, + 0xff, 0x40, 0x0, 0x0, 0x4, 0xff, 0xf9, 0x0, + 0x9, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x90, 0x0, 0x9f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x22, 0x21, 0x0, 0x1, 0x22, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0x33, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf3, 0x3f, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0x33, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xf3, 0x3f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x33, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf3, 0x3f, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x33, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf3, + 0x3f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x33, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xf3, 0x3f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x33, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf3, 0x3f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x32, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf2, 0x1f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0x10, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xe0, 0xc, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xfa, 0x0, 0x6f, 0xff, + 0xe1, 0x0, 0x0, 0x2, 0xef, 0xff, 0x40, 0x0, + 0xdf, 0xff, 0xe7, 0x10, 0x27, 0xef, 0xff, 0xb0, + 0x0, 0x2, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd1, 0x0, 0x0, 0x1, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xa1, 0x0, 0x0, 0x0, 0x0, 0x39, 0xdf, + 0xfe, 0xc8, 0x30, 0x0, 0x0, + + /* U+03CC "ό" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xaa, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0x8c, 0xef, 0xed, 0xa5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2b, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x60, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x4f, + 0xff, 0xfd, 0x62, 0x1, 0x4a, 0xff, 0xff, 0x80, + 0x0, 0xe, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0x40, 0x7, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xfc, 0x0, 0xdf, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf3, + 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x75, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xfb, 0x6f, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xc7, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xfd, 0x7f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xd6, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfc, 0x5f, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xa1, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xf6, 0xd, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x30, 0x7f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xc0, 0x0, 0xef, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xf4, 0x0, 0x4, 0xff, 0xff, 0xd6, + 0x10, 0x14, 0xaf, 0xff, 0xf9, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x2, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0xe6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x38, 0xce, + 0xff, 0xda, 0x50, 0x0, 0x0, 0x0, + + /* U+03CD "ύ" */ + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8a, 0xa4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf3, 0x3f, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0x33, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xf3, 0x3f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x33, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf3, 0x3f, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x33, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf3, + 0x3f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x33, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xf3, 0x3f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x33, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf3, 0x3f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x33, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf3, 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x21, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf1, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xfe, 0x0, 0xcf, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xa0, 0x6, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x2e, 0xff, 0xf4, + 0x0, 0xd, 0xff, 0xfe, 0x71, 0x2, 0x7e, 0xff, + 0xfb, 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x10, 0x0, 0x0, 0x1b, 0xff, 0xff, + 0xff, 0xff, 0xfa, 0x10, 0x0, 0x0, 0x0, 0x3, + 0x9d, 0xff, 0xec, 0x83, 0x0, 0x0, 0x0, + + /* U+03CE "ώ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9a, 0xa3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x10, 0x0, 0x0, 0xb, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xf8, 0x0, 0x0, 0x3, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf1, 0x0, 0x0, 0xaf, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x60, 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfc, + 0x0, 0x5, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x4, + 0x99, 0x92, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf2, + 0x0, 0x9f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x60, + 0xd, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf9, 0x0, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x1f, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xfe, 0x2, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf0, 0x3f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0x2, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xe0, 0x1f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xfd, 0x0, 0xef, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xb0, 0xa, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xf7, 0x0, 0x5f, 0xff, 0x90, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x20, 0x0, 0xef, 0xff, 0x30, 0x0, + 0x0, 0xcf, 0xfa, 0xff, 0x90, 0x0, 0x0, 0x7f, + 0xff, 0xc0, 0x0, 0x6, 0xff, 0xff, 0x50, 0x2, + 0xcf, 0xfb, 0xe, 0xff, 0xa1, 0x0, 0x7f, 0xff, + 0xf3, 0x0, 0x0, 0xa, 0xff, 0xff, 0xfe, 0xff, + 0xfe, 0x10, 0x4f, 0xff, 0xfe, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xfe, + 0x20, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xad, 0xff, 0xc7, 0x0, + 0x0, 0x0, 0x18, 0xdf, 0xfd, 0x82, 0x0, 0x0, + 0x0, + + /* U+03F4 "ϴ" */ + 0x0, 0x0, 0x0, 0x0, 0x78, 0x86, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf3, 0x0, 0x0, + 0x6e, 0xee, 0x10, 0xd, 0xff, 0x71, 0xee, 0xe6, + 0x7f, 0xff, 0x10, 0x5f, 0xfb, 0x1, 0xff, 0xf7, + 0x7f, 0xff, 0x10, 0xdf, 0xe1, 0x1, 0xff, 0xf7, + 0x7f, 0xff, 0x15, 0xff, 0x30, 0x1, 0xff, 0xf7 +}; + + +/*--------------------- + * GLYPH DESCRIPTION + *--------------------*/ + +static const lv_font_fmt_txt_glyph_dsc_t glyph_dsc[] = { + {.bitmap_index = 0, .adv_w = 0, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0} /* id = 0 reserved */, + {.bitmap_index = 0, .adv_w = 187, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 0, .adv_w = 187, .box_w = 6, .box_h = 30, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 90, .adv_w = 238, .box_w = 12, .box_h = 11, .ofs_x = 1, .ofs_y = 19}, + {.bitmap_index = 156, .adv_w = 374, .box_w = 23, .box_h = 32, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 524, .adv_w = 374, .box_w = 21, .box_h = 37, .ofs_x = 1, .ofs_y = -4}, + {.bitmap_index = 913, .adv_w = 598, .box_w = 33, .box_h = 32, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 1441, .adv_w = 449, .box_w = 27, .box_h = 32, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 1873, .adv_w = 127, .box_w = 6, .box_h = 11, .ofs_x = 1, .ofs_y = 19}, + {.bitmap_index = 1906, .adv_w = 224, .box_w = 11, .box_h = 39, .ofs_x = 2, .ofs_y = -8}, + {.bitmap_index = 2121, .adv_w = 224, .box_w = 11, .box_h = 39, .ofs_x = 1, .ofs_y = -8}, + {.bitmap_index = 2336, .adv_w = 261, .box_w = 14, .box_h = 13, .ofs_x = 1, .ofs_y = 17}, + {.bitmap_index = 2427, .adv_w = 392, .box_w = 21, .box_h = 20, .ofs_x = 2, .ofs_y = 5}, + {.bitmap_index = 2637, .adv_w = 187, .box_w = 5, .box_h = 11, .ofs_x = 3, .ofs_y = -6}, + {.bitmap_index = 2665, .adv_w = 224, .box_w = 12, .box_h = 4, .ofs_x = 1, .ofs_y = 9}, + {.bitmap_index = 2689, .adv_w = 187, .box_w = 5, .box_h = 5, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 2702, .adv_w = 187, .box_w = 12, .box_h = 31, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2888, .adv_w = 374, .box_w = 21, .box_h = 31, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 3214, .adv_w = 374, .box_w = 12, .box_h = 30, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 3394, .adv_w = 374, .box_w = 21, .box_h = 30, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 3709, .adv_w = 374, .box_w = 21, .box_h = 31, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 4035, .adv_w = 374, .box_w = 22, .box_h = 30, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4365, .adv_w = 374, .box_w = 21, .box_h = 31, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 4691, .adv_w = 374, .box_w = 21, .box_h = 31, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 5017, .adv_w = 374, .box_w = 20, .box_h = 30, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 5317, .adv_w = 374, .box_w = 21, .box_h = 31, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 5643, .adv_w = 374, .box_w = 21, .box_h = 31, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 5969, .adv_w = 187, .box_w = 5, .box_h = 22, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 6024, .adv_w = 187, .box_w = 5, .box_h = 28, .ofs_x = 3, .ofs_y = -6}, + {.bitmap_index = 6094, .adv_w = 392, .box_w = 21, .box_h = 21, .ofs_x = 2, .ofs_y = 4}, + {.bitmap_index = 6315, .adv_w = 392, .box_w = 21, .box_h = 13, .ofs_x = 2, .ofs_y = 8}, + {.bitmap_index = 6452, .adv_w = 392, .box_w = 21, .box_h = 21, .ofs_x = 2, .ofs_y = 4}, + {.bitmap_index = 6673, .adv_w = 374, .box_w = 21, .box_h = 31, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 6999, .adv_w = 682, .box_w = 40, .box_h = 39, .ofs_x = 2, .ofs_y = -8}, + {.bitmap_index = 7779, .adv_w = 449, .box_w = 30, .box_h = 30, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 8229, .adv_w = 449, .box_w = 23, .box_h = 30, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 8574, .adv_w = 485, .box_w = 27, .box_h = 32, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 9006, .adv_w = 485, .box_w = 26, .box_h = 30, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 9396, .adv_w = 449, .box_w = 23, .box_h = 30, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 9741, .adv_w = 411, .box_w = 21, .box_h = 30, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 10056, .adv_w = 523, .box_w = 28, .box_h = 32, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 10504, .adv_w = 485, .box_w = 24, .box_h = 30, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 10864, .adv_w = 187, .box_w = 5, .box_h = 30, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 10939, .adv_w = 336, .box_w = 17, .box_h = 31, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 11203, .adv_w = 449, .box_w = 25, .box_h = 30, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 11578, .adv_w = 374, .box_w = 19, .box_h = 30, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 11863, .adv_w = 560, .box_w = 29, .box_h = 30, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 12298, .adv_w = 485, .box_w = 25, .box_h = 30, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 12673, .adv_w = 523, .box_w = 30, .box_h = 32, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 13153, .adv_w = 449, .box_w = 24, .box_h = 30, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 13513, .adv_w = 523, .box_w = 31, .box_h = 34, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 14040, .adv_w = 485, .box_w = 27, .box_h = 30, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 14445, .adv_w = 449, .box_w = 25, .box_h = 32, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 14845, .adv_w = 411, .box_w = 25, .box_h = 30, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 15220, .adv_w = 485, .box_w = 24, .box_h = 31, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 15592, .adv_w = 449, .box_w = 28, .box_h = 30, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 16012, .adv_w = 634, .box_w = 40, .box_h = 30, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 16612, .adv_w = 449, .box_w = 28, .box_h = 30, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 17032, .adv_w = 449, .box_w = 28, .box_h = 30, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 17452, .adv_w = 411, .box_w = 25, .box_h = 30, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 17827, .adv_w = 187, .box_w = 9, .box_h = 38, .ofs_x = 2, .ofs_y = -8}, + {.bitmap_index = 17998, .adv_w = 187, .box_w = 12, .box_h = 31, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 18184, .adv_w = 187, .box_w = 9, .box_h = 38, .ofs_x = 0, .ofs_y = -8}, + {.bitmap_index = 18355, .adv_w = 315, .box_w = 18, .box_h = 16, .ofs_x = 1, .ofs_y = 14}, + {.bitmap_index = 18499, .adv_w = 374, .box_w = 25, .box_h = 3, .ofs_x = -1, .ofs_y = -8}, + {.bitmap_index = 18537, .adv_w = 224, .box_w = 9, .box_h = 6, .ofs_x = 1, .ofs_y = 24}, + {.bitmap_index = 18564, .adv_w = 374, .box_w = 21, .box_h = 22, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 18795, .adv_w = 374, .box_w = 20, .box_h = 30, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 19095, .adv_w = 336, .box_w = 20, .box_h = 22, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 19315, .adv_w = 374, .box_w = 20, .box_h = 30, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 19615, .adv_w = 374, .box_w = 21, .box_h = 22, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 19846, .adv_w = 187, .box_w = 14, .box_h = 31, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 20063, .adv_w = 374, .box_w = 20, .box_h = 30, .ofs_x = 1, .ofs_y = -8}, + {.bitmap_index = 20363, .adv_w = 374, .box_w = 19, .box_h = 30, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 20648, .adv_w = 149, .box_w = 5, .box_h = 30, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 20723, .adv_w = 149, .box_w = 9, .box_h = 38, .ofs_x = -2, .ofs_y = -8}, + {.bitmap_index = 20894, .adv_w = 336, .box_w = 19, .box_h = 30, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 21179, .adv_w = 149, .box_w = 5, .box_h = 30, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 21254, .adv_w = 560, .box_w = 31, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 21595, .adv_w = 374, .box_w = 19, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 21804, .adv_w = 374, .box_w = 21, .box_h = 22, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 22035, .adv_w = 374, .box_w = 20, .box_h = 30, .ofs_x = 2, .ofs_y = -8}, + {.bitmap_index = 22335, .adv_w = 374, .box_w = 20, .box_h = 30, .ofs_x = 1, .ofs_y = -8}, + {.bitmap_index = 22635, .adv_w = 224, .box_w = 13, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 22778, .adv_w = 336, .box_w = 19, .box_h = 22, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 22987, .adv_w = 187, .box_w = 12, .box_h = 30, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 23167, .adv_w = 374, .box_w = 19, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 23376, .adv_w = 336, .box_w = 21, .box_h = 22, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 23607, .adv_w = 485, .box_w = 31, .box_h = 22, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 23948, .adv_w = 336, .box_w = 21, .box_h = 22, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 24179, .adv_w = 336, .box_w = 21, .box_h = 30, .ofs_x = 0, .ofs_y = -8}, + {.bitmap_index = 24494, .adv_w = 336, .box_w = 21, .box_h = 22, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 24725, .adv_w = 224, .box_w = 13, .box_h = 39, .ofs_x = 1, .ofs_y = -8}, + {.bitmap_index = 24979, .adv_w = 175, .box_w = 5, .box_h = 39, .ofs_x = 3, .ofs_y = -8}, + {.bitmap_index = 25077, .adv_w = 224, .box_w = 13, .box_h = 39, .ofs_x = 0, .ofs_y = -8}, + {.bitmap_index = 25331, .adv_w = 392, .box_w = 22, .box_h = 8, .ofs_x = 1, .ofs_y = 10}, + {.bitmap_index = 25419, .adv_w = 187, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 25419, .adv_w = 374, .box_w = 23, .box_h = 32, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 25787, .adv_w = 374, .box_w = 21, .box_h = 21, .ofs_x = 1, .ofs_y = 4}, + {.bitmap_index = 26008, .adv_w = 374, .box_w = 24, .box_h = 30, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 26368, .adv_w = 175, .box_w = 5, .box_h = 39, .ofs_x = 3, .ofs_y = -8}, + {.bitmap_index = 26466, .adv_w = 374, .box_w = 21, .box_h = 39, .ofs_x = 1, .ofs_y = -8}, + {.bitmap_index = 26876, .adv_w = 224, .box_w = 12, .box_h = 5, .ofs_x = 1, .ofs_y = 26}, + {.bitmap_index = 26906, .adv_w = 495, .box_w = 31, .box_h = 31, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 27387, .adv_w = 252, .box_w = 16, .box_h = 15, .ofs_x = 0, .ofs_y = 15}, + {.bitmap_index = 27507, .adv_w = 374, .box_w = 19, .box_h = 19, .ofs_x = 2, .ofs_y = 1}, + {.bitmap_index = 27688, .adv_w = 392, .box_w = 21, .box_h = 13, .ofs_x = 2, .ofs_y = 8}, + {.bitmap_index = 27825, .adv_w = 224, .box_w = 12, .box_h = 4, .ofs_x = 1, .ofs_y = 9}, + {.bitmap_index = 27849, .adv_w = 495, .box_w = 31, .box_h = 31, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 28330, .adv_w = 269, .box_w = 13, .box_h = 12, .ofs_x = 2, .ofs_y = 19}, + {.bitmap_index = 28408, .adv_w = 392, .box_w = 21, .box_h = 25, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 28671, .adv_w = 224, .box_w = 14, .box_h = 15, .ofs_x = 0, .ofs_y = 15}, + {.bitmap_index = 28776, .adv_w = 224, .box_w = 14, .box_h = 15, .ofs_x = 0, .ofs_y = 15}, + {.bitmap_index = 28881, .adv_w = 374, .box_w = 19, .box_h = 30, .ofs_x = 2, .ofs_y = -8}, + {.bitmap_index = 29166, .adv_w = 361, .box_w = 24, .box_h = 38, .ofs_x = -1, .ofs_y = -8}, + {.bitmap_index = 29622, .adv_w = 188, .box_w = 5, .box_h = 5, .ofs_x = 3, .ofs_y = 13}, + {.bitmap_index = 29635, .adv_w = 374, .box_w = 19, .box_h = 19, .ofs_x = 2, .ofs_y = 1}, + {.bitmap_index = 29816, .adv_w = 560, .box_w = 33, .box_h = 32, .ofs_x = 2, .ofs_y = -2}, + {.bitmap_index = 30344, .adv_w = 224, .box_w = 9, .box_h = 6, .ofs_x = 4, .ofs_y = 25}, + {.bitmap_index = 30371, .adv_w = 449, .box_w = 30, .box_h = 30, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 30821, .adv_w = 527, .box_w = 33, .box_h = 30, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 31316, .adv_w = 563, .box_w = 33, .box_h = 30, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 31811, .adv_w = 258, .box_w = 14, .box_h = 30, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 32021, .adv_w = 520, .box_w = 33, .box_h = 32, .ofs_x = -2, .ofs_y = -1}, + {.bitmap_index = 32549, .adv_w = 575, .box_w = 38, .box_h = 30, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 33119, .adv_w = 506, .box_w = 32, .box_h = 31, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 33615, .adv_w = 149, .box_w = 16, .box_h = 31, .ofs_x = -3, .ofs_y = 0}, + {.bitmap_index = 33863, .adv_w = 449, .box_w = 30, .box_h = 30, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 34313, .adv_w = 449, .box_w = 23, .box_h = 30, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 34658, .adv_w = 370, .box_w = 20, .box_h = 30, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 34958, .adv_w = 449, .box_w = 30, .box_h = 30, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 35408, .adv_w = 449, .box_w = 23, .box_h = 30, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 35753, .adv_w = 411, .box_w = 25, .box_h = 30, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 36128, .adv_w = 485, .box_w = 24, .box_h = 30, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 36488, .adv_w = 523, .box_w = 30, .box_h = 32, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 36968, .adv_w = 187, .box_w = 5, .box_h = 30, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 37043, .adv_w = 449, .box_w = 25, .box_h = 30, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 37418, .adv_w = 449, .box_w = 28, .box_h = 30, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 37838, .adv_w = 560, .box_w = 29, .box_h = 30, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 38273, .adv_w = 485, .box_w = 25, .box_h = 30, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 38648, .adv_w = 437, .box_w = 24, .box_h = 30, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 39008, .adv_w = 523, .box_w = 30, .box_h = 32, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 39488, .adv_w = 485, .box_w = 24, .box_h = 30, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 39848, .adv_w = 449, .box_w = 24, .box_h = 30, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 40208, .adv_w = 415, .box_w = 22, .box_h = 30, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 40538, .adv_w = 411, .box_w = 25, .box_h = 30, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 40913, .adv_w = 449, .box_w = 28, .box_h = 30, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 41333, .adv_w = 536, .box_w = 31, .box_h = 32, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 41829, .adv_w = 449, .box_w = 28, .box_h = 30, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 42249, .adv_w = 561, .box_w = 31, .box_h = 30, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 42714, .adv_w = 502, .box_w = 29, .box_h = 31, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 43164, .adv_w = 187, .box_w = 13, .box_h = 36, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 43398, .adv_w = 449, .box_w = 28, .box_h = 36, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 43902, .adv_w = 389, .box_w = 22, .box_h = 31, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 44243, .adv_w = 300, .box_w = 16, .box_h = 31, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 44491, .adv_w = 374, .box_w = 19, .box_h = 39, .ofs_x = 2, .ofs_y = -8}, + {.bitmap_index = 44862, .adv_w = 149, .box_w = 8, .box_h = 31, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 44986, .adv_w = 368, .box_w = 19, .box_h = 31, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 45281, .adv_w = 389, .box_w = 22, .box_h = 22, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 45523, .adv_w = 387, .box_w = 21, .box_h = 39, .ofs_x = 2, .ofs_y = -8}, + {.bitmap_index = 45933, .adv_w = 336, .box_w = 21, .box_h = 30, .ofs_x = 0, .ofs_y = -8}, + {.bitmap_index = 46248, .adv_w = 374, .box_w = 21, .box_h = 30, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 46563, .adv_w = 300, .box_w = 16, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 46739, .adv_w = 296, .box_w = 18, .box_h = 38, .ofs_x = 1, .ofs_y = -8}, + {.bitmap_index = 47081, .adv_w = 374, .box_w = 19, .box_h = 30, .ofs_x = 2, .ofs_y = -8}, + {.bitmap_index = 47366, .adv_w = 374, .box_w = 21, .box_h = 31, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 47692, .adv_w = 149, .box_w = 5, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 47747, .adv_w = 335, .box_w = 19, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 47956, .adv_w = 336, .box_w = 21, .box_h = 30, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 48271, .adv_w = 374, .box_w = 19, .box_h = 30, .ofs_x = 2, .ofs_y = -8}, + {.bitmap_index = 48556, .adv_w = 336, .box_w = 21, .box_h = 22, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 48787, .adv_w = 301, .box_w = 18, .box_h = 39, .ofs_x = 1, .ofs_y = -8}, + {.bitmap_index = 49138, .adv_w = 374, .box_w = 21, .box_h = 22, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 49369, .adv_w = 464, .box_w = 29, .box_h = 22, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 49688, .adv_w = 382, .box_w = 21, .box_h = 30, .ofs_x = 2, .ofs_y = -8}, + {.bitmap_index = 50003, .adv_w = 324, .box_w = 19, .box_h = 30, .ofs_x = 1, .ofs_y = -8}, + {.bitmap_index = 50288, .adv_w = 415, .box_w = 24, .box_h = 22, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 50552, .adv_w = 265, .box_w = 16, .box_h = 22, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 50728, .adv_w = 368, .box_w = 19, .box_h = 22, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 50937, .adv_w = 436, .box_w = 25, .box_h = 30, .ofs_x = 1, .ofs_y = -8}, + {.bitmap_index = 51312, .adv_w = 353, .box_w = 22, .box_h = 30, .ofs_x = 0, .ofs_y = -8}, + {.bitmap_index = 51642, .adv_w = 479, .box_w = 26, .box_h = 30, .ofs_x = 2, .ofs_y = -8}, + {.bitmap_index = 52032, .adv_w = 525, .box_w = 31, .box_h = 22, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 52373, .adv_w = 149, .box_w = 13, .box_h = 30, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 52568, .adv_w = 368, .box_w = 19, .box_h = 30, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 52853, .adv_w = 374, .box_w = 21, .box_h = 31, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 53179, .adv_w = 368, .box_w = 19, .box_h = 31, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 53474, .adv_w = 525, .box_w = 31, .box_h = 31, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 53955, .adv_w = 224, .box_w = 16, .box_h = 6, .ofs_x = -1, .ofs_y = 25} +}; + +/*--------------------- + * CHARACTER MAPPING + *--------------------*/ + +static const uint8_t glyph_id_ofs_list_1[] = { + 0, 0, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 0, + 13, 14, 15, 16, 0, 17, 18, 19, + 0, 0, 0, 20, 0, 21 +}; + +static const uint8_t glyph_id_ofs_list_2[] = { + 0, 0, 1, 0, 2, 3, 4, 0, + 5 +}; + +/*Collect the unicode lists and glyph_id offsets*/ +static const lv_font_fmt_txt_cmap_t cmaps[] = +{ + { + .range_start = 32, .range_length = 95, .glyph_id_start = 1, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 160, .range_length = 30, .glyph_id_start = 96, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_1, .list_length = 30, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 900, .range_length = 9, .glyph_id_start = 118, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_2, .list_length = 9, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 910, .range_length = 20, .glyph_id_start = 124, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 931, .range_length = 44, .glyph_id_start = 144, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 1012, .range_length = 1, .glyph_id_start = 188, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + } +}; + + + +/*-------------------- + * ALL CUSTOM DATA + *--------------------*/ + +#if LVGL_VERSION_MAJOR == 8 +/*Store all the custom data of the font*/ +static lv_font_fmt_txt_glyph_cache_t cache; +#endif + +#if LVGL_VERSION_MAJOR >= 8 +static const lv_font_fmt_txt_dsc_t font_dsc = { +#else +static lv_font_fmt_txt_dsc_t font_dsc = { +#endif + .glyph_bitmap = glyph_bitmap, + .glyph_dsc = glyph_dsc, + .cmaps = cmaps, + .kern_dsc = NULL, + .kern_scale = 0, + .cmap_num = 6, + .bpp = 4, + .kern_classes = 0, + .bitmap_format = 0, +#if LVGL_VERSION_MAJOR == 8 + .cache = &cache +#endif + +}; + +extern const lv_font_t lv_font_montserrat_42; + + +/*----------------- + * PUBLIC FONT + *----------------*/ + +/*Initialize a public general font descriptor*/ +#if LVGL_VERSION_MAJOR >= 8 +const lv_font_t lv_font_arial_42 = { +#else +lv_font_t lv_font_arial_42 = { +#endif + .get_glyph_dsc = lv_font_get_glyph_dsc_fmt_txt, /*Function pointer to get glyph's data*/ + .get_glyph_bitmap = lv_font_get_bitmap_fmt_txt, /*Function pointer to get glyph's bitmap*/ + .line_height = 44, /*The maximum line height required by the font*/ + .base_line = 8, /*Baseline measured from the bottom of the line*/ +#if !(LVGL_VERSION_MAJOR == 6 && LVGL_VERSION_MINOR == 0) + .subpx = LV_FONT_SUBPX_NONE, +#endif +#if LV_VERSION_CHECK(7, 4, 0) || LVGL_VERSION_MAJOR >= 8 + .underline_position = -4, + .underline_thickness = 3, +#endif + //.static_bitmap = 0, + .dsc = &font_dsc, /*The custom font data. Will be accessed by `get_glyph_bitmap/dsc` */ +#if LV_VERSION_CHECK(8, 2, 0) || LVGL_VERSION_MAJOR >= 9 + .fallback = &lv_font_montserrat_42, +#endif + .user_data = NULL, +}; + + + +#endif /*#if LV_FONT_ARIAL_42*/ diff --git a/src/fonts/lv_font_arial_44.c b/src/fonts/lv_font_arial_44.c new file mode 100644 index 0000000000..40a7dcf35d --- /dev/null +++ b/src/fonts/lv_font_arial_44.c @@ -0,0 +1,8210 @@ +/******************************************************************************* + * Size: 44 px + * Bpp: 4 + * Opts: --bpp 4 --size 44 --no-compress --stride 1 --align 1 --font Arial Greek Regular.ttf --range 32-127,160-255,880-1023 --format lvgl -o lv_font_arial_44.c + ******************************************************************************/ + +#ifdef __has_include + #if __has_include("lvgl.h") + #ifndef LV_LVGL_H_INCLUDE_SIMPLE + #define LV_LVGL_H_INCLUDE_SIMPLE + #endif + #endif +#endif + +#ifdef LV_LVGL_H_INCLUDE_SIMPLE + #include "lvgl.h" +#else + #include "lvgl/lvgl.h" +#endif + + + +#ifndef LV_FONT_ARIAL_44 +#define LV_FONT_ARIAL_44 1 +#endif + +#if LV_FONT_ARIAL_44 + +/*----------------- + * BITMAPS + *----------------*/ + +/*Store the image of the glyphs*/ +static LV_ATTRIBUTE_LARGE_CONST const uint8_t glyph_bitmap[] = { + /* U+0020 " " */ + + /* U+0021 "!" */ + 0x4f, 0xff, 0xf8, 0x4f, 0xff, 0xf8, 0x4f, 0xff, + 0xf8, 0x4f, 0xff, 0xf8, 0x4f, 0xff, 0xf8, 0x4f, + 0xff, 0xf8, 0x4f, 0xff, 0xf8, 0x3f, 0xff, 0xf7, + 0x2f, 0xff, 0xf6, 0x1f, 0xff, 0xf5, 0xf, 0xff, + 0xf4, 0xf, 0xff, 0xf3, 0xe, 0xff, 0xf2, 0xc, + 0xff, 0xf0, 0xb, 0xff, 0xf0, 0xa, 0xff, 0xe0, + 0x9, 0xff, 0xd0, 0x8, 0xff, 0xc0, 0x7, 0xff, + 0xb0, 0x5, 0xff, 0xa0, 0x4, 0xff, 0x90, 0x3, + 0xff, 0x80, 0x2, 0xff, 0x70, 0x0, 0x55, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0x55, + 0x51, 0x1f, 0xff, 0xf5, 0x1f, 0xff, 0xf5, 0x1f, + 0xff, 0xf5, 0x1f, 0xff, 0xf5, + + /* U+0022 "\"" */ + 0xff, 0xff, 0x70, 0xd, 0xff, 0xf9, 0xff, 0xff, + 0x70, 0xd, 0xff, 0xf9, 0xff, 0xff, 0x70, 0xd, + 0xff, 0xf9, 0xff, 0xff, 0x70, 0xd, 0xff, 0xf9, + 0xff, 0xff, 0x70, 0xd, 0xff, 0xf9, 0xef, 0xff, + 0x60, 0xc, 0xff, 0xf8, 0xbf, 0xff, 0x30, 0x9, + 0xff, 0xf5, 0x8f, 0xff, 0x0, 0x6, 0xff, 0xf2, + 0x5f, 0xfe, 0x0, 0x3, 0xff, 0xf0, 0x2f, 0xfb, + 0x0, 0x0, 0xff, 0xc0, 0xf, 0xf8, 0x0, 0x0, + 0xdf, 0x90, + + /* U+0023 "#" */ + 0x0, 0x0, 0x0, 0x0, 0x2d, 0xdd, 0x0, 0x0, + 0x0, 0x2d, 0xdd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xfd, 0x0, 0x0, 0x0, 0x6f, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfa, 0x0, 0x0, + 0x0, 0x9f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xf6, 0x0, 0x0, 0x0, 0xcf, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf0, 0x0, 0x0, 0x3, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xc0, 0x0, 0x0, + 0x7, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0x90, 0x0, 0x0, 0xa, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0x50, 0x0, 0x0, + 0xd, 0xff, 0x60, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x12, 0x22, 0x22, 0xbf, 0xf9, 0x22, 0x22, 0x22, + 0xbf, 0xf9, 0x22, 0x22, 0x0, 0x0, 0x0, 0xdf, + 0xf5, 0x0, 0x0, 0x0, 0xef, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xf2, 0x0, 0x0, 0x1, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xe0, 0x0, 0x0, 0x5, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xb0, 0x0, 0x0, 0x8, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0x80, 0x0, 0x0, 0xb, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0x40, 0x0, 0x0, 0xe, + 0xff, 0x40, 0x0, 0x0, 0x12, 0x22, 0x3f, 0xff, + 0x42, 0x22, 0x22, 0x4f, 0xff, 0x42, 0x22, 0x22, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0xef, 0xf4, + 0x0, 0x0, 0x0, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xf1, 0x0, 0x0, 0x2, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xe0, + 0x0, 0x0, 0x5, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xa0, 0x0, 0x0, 0x9, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x70, + 0x0, 0x0, 0xc, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0x40, 0x0, 0x0, 0xf, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x10, + 0x0, 0x0, 0x2f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xfd, 0x0, 0x0, 0x0, 0x5f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfa, 0x0, + 0x0, 0x0, 0x9f, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x12, 0x21, 0x0, 0x0, 0x0, 0x12, 0x21, + 0x0, 0x0, 0x0, 0x0, + + /* U+0024 "$" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5b, 0xef, 0xff, 0xff, 0xc7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4d, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x2f, 0xff, 0xfd, 0x61, 0xff, 0x67, 0xef, 0xff, + 0xf4, 0x0, 0x0, 0xbf, 0xff, 0xb0, 0x0, 0xff, + 0x50, 0x1c, 0xff, 0xfd, 0x0, 0x2, 0xff, 0xfe, + 0x0, 0x0, 0xff, 0x50, 0x2, 0xff, 0xff, 0x30, + 0x7, 0xff, 0xf7, 0x0, 0x0, 0xff, 0x50, 0x0, + 0xbf, 0xff, 0x80, 0x9, 0xff, 0xf4, 0x0, 0x0, + 0xff, 0x50, 0x0, 0x6f, 0xda, 0x50, 0xa, 0xff, + 0xf3, 0x0, 0x0, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf5, 0x0, 0x0, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfb, 0x0, + 0x0, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0x70, 0x0, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf9, 0x10, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0xfa, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xdf, 0xff, 0xff, 0xff, 0xea, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x19, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x91, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x18, 0xdf, 0xff, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xef, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0x52, 0x9f, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0x50, 0x3, 0xef, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0x50, 0x0, 0x4f, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0x50, 0x0, 0xc, 0xff, 0xf5, + 0x0, 0x3, 0x30, 0x0, 0x0, 0xff, 0x50, 0x0, + 0x9, 0xff, 0xf7, 0x3d, 0xff, 0xb0, 0x0, 0x0, + 0xff, 0x50, 0x0, 0x8, 0xff, 0xf7, 0x2f, 0xff, + 0xf0, 0x0, 0x0, 0xff, 0x50, 0x0, 0x9, 0xff, + 0xf6, 0xf, 0xff, 0xf4, 0x0, 0x0, 0xff, 0x50, + 0x0, 0xd, 0xff, 0xf3, 0xb, 0xff, 0xfc, 0x0, + 0x0, 0xff, 0x50, 0x0, 0x4f, 0xff, 0xe0, 0x4, + 0xff, 0xff, 0x70, 0x0, 0xff, 0x50, 0x2, 0xef, + 0xff, 0x70, 0x0, 0xbf, 0xff, 0xf8, 0x0, 0xff, + 0x50, 0x5e, 0xff, 0xfd, 0x0, 0x0, 0x1d, 0xff, + 0xff, 0xfb, 0xff, 0xce, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x1, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x30, 0x0, 0x0, 0x0, 0x5, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0x81, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x58, 0xff, 0xa6, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x78, + 0x20, 0x0, 0x0, 0x0, 0x0, + + /* U+0025 "%" */ + 0x0, 0x0, 0x4, 0x67, 0x51, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x48, 0x84, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4e, 0xff, 0xff, 0xfa, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xc4, + 0x25, 0xef, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xe0, 0x0, 0x2, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xf7, 0x0, 0x0, 0xa, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0x30, 0x0, 0x0, 0x6f, 0xfe, + 0x0, 0x0, 0x0, 0x8, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xf1, 0x0, 0x0, 0x5, + 0xff, 0xf0, 0x0, 0x0, 0x1, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x10, 0x0, 0x0, 0x9f, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf0, + 0x0, 0x0, 0x4, 0xff, 0xf0, 0x0, 0x0, 0x2f, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0x10, 0x0, 0x0, 0x6f, 0xff, 0x0, 0x0, + 0xa, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf4, 0x0, 0x0, 0x9, 0xff, 0xc0, + 0x0, 0x3, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0x90, 0x0, 0x0, 0xef, + 0xf8, 0x0, 0x0, 0xbf, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x40, 0x0, + 0x9f, 0xff, 0x10, 0x0, 0x4f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xca, 0xdf, 0xff, 0x60, 0x0, 0xc, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0x70, 0x0, 0x5, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5b, 0xef, 0xd9, 0x20, 0x0, 0x0, + 0xdf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xfc, 0x0, 0x0, 0x3, 0xae, 0xfe, + 0xc6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0x30, 0x0, 0x7, 0xff, + 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xb0, 0x0, 0x6, + 0xff, 0xfe, 0xab, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf3, 0x0, + 0x1, 0xff, 0xfa, 0x0, 0x2, 0xef, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfa, + 0x0, 0x0, 0x7f, 0xff, 0x0, 0x0, 0x7, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x20, 0x0, 0xb, 0xff, 0xa0, 0x0, 0x0, + 0x1f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0x90, 0x0, 0x0, 0xef, 0xf7, 0x0, + 0x0, 0x0, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xf1, 0x0, 0x0, 0xf, 0xff, + 0x60, 0x0, 0x0, 0xe, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xf8, 0x0, 0x0, 0x0, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0xef, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x10, 0x0, + 0x0, 0xd, 0xff, 0x70, 0x0, 0x0, 0xf, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0x70, + 0x0, 0x0, 0x0, 0xbf, 0xf9, 0x0, 0x0, 0x2, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xe0, 0x0, + 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0x90, 0x0, 0x3f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xda, 0xbf, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xc1, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2a, 0xef, 0xeb, 0x50, + 0x0, 0x0, + + /* U+0026 "&" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x36, 0x76, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7e, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfc, + 0xad, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xfe, 0x30, 0x0, 0x4f, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xf3, 0x0, 0x0, 0x6, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf2, 0x0, 0x0, 0x3, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xfb, 0x0, 0x0, 0xb, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0x80, 0x0, 0x9f, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf6, + 0x1b, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xfc, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xef, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xcf, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xef, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xe4, 0x1d, 0xff, 0xff, 0x50, 0x0, + 0x7, 0x51, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, + 0x10, 0x2, 0xff, 0xff, 0xf2, 0x0, 0x1f, 0xff, + 0xe1, 0x0, 0x1, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x4f, 0xff, 0xfd, 0x10, 0x6f, 0xff, 0xd0, 0x0, + 0x8, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xb0, 0xcf, 0xff, 0x80, 0x0, 0xd, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfb, + 0xff, 0xff, 0x20, 0x0, 0xf, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x1f, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0xf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0xd, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xd1, 0x0, 0x0, 0x7, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xd1, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x6f, 0xff, 0xfe, 0x61, 0x0, 0x17, 0xef, + 0xff, 0xfb, 0xdf, 0xff, 0xfd, 0x10, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xee, 0xff, 0xff, 0xff, 0xa0, + 0x1e, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x2, 0xdf, + 0xff, 0x90, 0x0, 0x0, 0x2, 0xaf, 0xff, 0xff, + 0xff, 0xe8, 0x10, 0x0, 0x0, 0x1c, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x46, 0x77, 0x63, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x70, 0x0, + + /* U+0027 "'" */ + 0xff, 0xff, 0x6f, 0xff, 0xf6, 0xff, 0xff, 0x6f, + 0xff, 0xf6, 0xff, 0xff, 0x6f, 0xff, 0xf5, 0xcf, + 0xff, 0x29, 0xff, 0xf0, 0x7f, 0xfd, 0x4, 0xff, + 0xa0, 0x1f, 0xf7, 0x0, + + /* U+0028 "(" */ + 0x0, 0x0, 0x0, 0x0, 0x78, 0x70, 0x0, 0x0, + 0x0, 0x6, 0xff, 0x70, 0x0, 0x0, 0x0, 0x2f, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf4, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x8f, 0xfd, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xf0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x40, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xe0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x10, 0x0, + 0x0, 0x0, 0xc, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xc0, + + /* U+0029 ")" */ + 0x28, 0x84, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf2, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0x70, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0x10, 0x0, 0x0, 0x0, 0xaf, 0xfa, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0x60, 0x0, 0x0, 0x1, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0x30, 0x0, 0x0, 0x6, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xa0, 0x0, 0x0, + 0x2, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0x0, 0x0, 0x0, 0xf, 0xff, 0xe0, 0x0, + 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xb0, 0x0, 0x0, 0x5, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x60, 0x0, 0x0, 0xb, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0xef, 0xfe, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0x90, 0x0, 0x0, 0x7, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0xdf, 0xfd, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x60, 0x0, 0x0, 0x8, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0xef, 0xf7, 0x0, + 0x0, 0x0, 0x6f, 0xfe, 0x0, 0x0, 0x0, 0xd, + 0xff, 0x60, 0x0, 0x0, 0x6, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0xef, 0xf2, 0x0, 0x0, 0x0, 0x8f, + 0xf7, 0x0, 0x0, 0x0, 0x2f, 0xfb, 0x0, 0x0, + 0x0, 0x0, + + /* U+002A "*" */ + 0x0, 0x0, 0x0, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf0, 0x0, 0x0, 0x0, 0x76, + 0x10, 0xc, 0xfd, 0x0, 0x5, 0x80, 0xf, 0xff, + 0xa3, 0xaf, 0xb2, 0x9f, 0xff, 0x14, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf6, 0x27, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xd8, 0x30, 0x0, 0x2, 0xbf, + 0xff, 0xb3, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfe, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x2e, + 0xff, 0x50, 0x0, 0x0, 0x2e, 0xff, 0x70, 0x6f, + 0xff, 0x40, 0x0, 0x8, 0xff, 0xd0, 0x0, 0xcf, + 0xfb, 0x0, 0x0, 0x5, 0xe3, 0x0, 0x2, 0xe7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+002B "+" */ + 0x0, 0x0, 0x0, 0x0, 0x8, 0x88, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x8f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf4, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x49, 0x99, 0x99, 0x99, + 0x9f, 0xff, 0xd9, 0x99, 0x99, 0x99, 0x92, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + + /* U+002C "," */ + 0x5, 0x55, 0x51, 0x2f, 0xff, 0xf3, 0x2f, 0xff, + 0xf3, 0x2f, 0xff, 0xf3, 0x2f, 0xff, 0xf3, 0x0, + 0xf, 0xf2, 0x0, 0x2f, 0xf1, 0x0, 0x7f, 0xd0, + 0x2, 0xff, 0x70, 0x3f, 0xfc, 0x0, 0xc, 0x91, + 0x0, 0x0, 0x0, 0x0, + + /* U+002D "-" */ + 0x8d, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0x39, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf4, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x49, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf4, + + /* U+002E "." */ + 0x5, 0x55, 0x51, 0x1f, 0xff, 0xf5, 0x1f, 0xff, + 0xf5, 0x1f, 0xff, 0xf5, 0x1f, 0xff, 0xf5, + + /* U+002F "/" */ + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x2, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x30, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xf6, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x4, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + + /* U+0030 "0" */ + 0x0, 0x0, 0x0, 0x4, 0xad, 0xef, 0xdb, 0x61, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xd7, 0x33, 0x5b, + 0xff, 0xff, 0x80, 0x0, 0x0, 0xc, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf2, 0x0, 0x0, + 0x5f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xfa, 0x0, 0x0, 0xcf, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0x10, 0x1, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x60, + 0x5, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xb0, 0x8, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xe0, 0xb, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xf0, 0xd, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf3, 0xf, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf4, 0xf, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xf5, 0xf, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xf6, 0x1f, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf7, + 0x1f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xf6, 0xf, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xf5, 0xf, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf5, 0xe, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf4, 0xc, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf2, 0xa, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf0, 0x7, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xd0, 0x3, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x80, + 0x0, 0xef, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x40, 0x0, 0x9f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xfe, 0x0, 0x0, 0x1f, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf6, + 0x0, 0x0, 0x8, 0xff, 0xff, 0x60, 0x0, 0x3, + 0xdf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xfe, 0xba, 0xdf, 0xff, 0xfe, 0x20, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5c, 0xff, 0xff, + 0xff, 0xe8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x25, 0x67, 0x53, 0x0, 0x0, 0x0, 0x0, + + /* U+0031 "1" */ + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xf7, 0x0, 0x0, 0x1, 0xbf, 0xff, 0xff, + 0x70, 0x0, 0x4, 0xef, 0xff, 0xff, 0xf7, 0x0, + 0x1a, 0xff, 0xff, 0xff, 0xff, 0x70, 0x8f, 0xff, + 0xff, 0xc7, 0xff, 0xf7, 0x2f, 0xff, 0xff, 0x80, + 0x6f, 0xff, 0x72, 0xff, 0xfc, 0x30, 0x6, 0xff, + 0xf7, 0x2f, 0xb4, 0x0, 0x0, 0x6f, 0xff, 0x70, + 0x20, 0x0, 0x0, 0x6, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x70, + + /* U+0032 "2" */ + 0x0, 0x0, 0x0, 0x17, 0xad, 0xff, 0xed, 0x95, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd4, 0x0, 0x0, 0x0, 0x2, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x1d, 0xff, 0xff, 0xb6, 0x32, 0x48, + 0xef, 0xff, 0xf6, 0x0, 0x0, 0x9f, 0xff, 0xe3, + 0x0, 0x0, 0x0, 0x1b, 0xff, 0xff, 0x10, 0x1, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x90, 0x7, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xe0, 0xa, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf0, + 0xc, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xf2, 0x0, 0x12, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xcf, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2e, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xfe, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1c, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xa2, 0x4f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf3, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf3, + + /* U+0033 "3" */ + 0x0, 0x0, 0x0, 0x17, 0xbe, 0xff, 0xda, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x50, 0x0, 0x0, 0x0, 0x1, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0x94, 0x23, 0x6c, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x7f, 0xff, 0xe3, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf2, 0x0, 0x0, + 0xef, 0xff, 0x40, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf9, 0x0, 0x4, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xfd, 0x0, 0x8, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, + 0x0, 0x25, 0x82, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0x8e, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0xc2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0x82, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xfe, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x12, 0x0, 0x4, 0xbf, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xf8, 0x4, 0x68, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf7, 0xe, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf6, + 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xf2, 0x6, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xd0, 0x0, 0xef, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x40, 0x0, 0x4f, 0xff, 0xfb, 0x20, 0x0, 0x2, + 0xaf, 0xff, 0xf9, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xfd, 0xbb, 0xdf, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x9f, 0xff, 0xff, + 0xff, 0xe9, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x36, 0x77, 0x63, 0x0, 0x0, 0x0, 0x0, + + /* U+0034 "4" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xfe, 0xcf, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x4b, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x90, 0xbf, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xd0, 0xb, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xf3, 0x0, 0xbf, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf7, 0x0, 0xb, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xfc, 0x0, + 0x0, 0xbf, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xfe, 0x10, 0x0, 0xb, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x50, 0x0, 0x0, + 0xbf, 0xff, 0x20, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xa0, 0x0, 0x0, 0xb, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xd0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x20, 0x0, 0x0, 0x9, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf2, 0x0, 0x0, 0x4, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x20, 0x0, 0x1, 0xef, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf2, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x75, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf7, 0x5f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x72, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x8d, + 0xff, 0xf9, 0x88, 0x83, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x20, 0x0, 0x0, + + /* U+0035 "5" */ + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0xff, 0xfe, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0x30, 0x0, 0x2, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x70, 0x0, 0x35, 0x53, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x44, 0xbf, 0xff, 0xff, + 0xfb, 0x40, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0x10, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd1, 0x0, 0x0, 0xff, 0xff, 0xfd, 0x62, 0x0, + 0x26, 0xdf, 0xff, 0xfd, 0x0, 0x3, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x80, + 0x3, 0x9b, 0xd9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xfb, 0x1, 0x34, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf9, 0xf, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf6, + 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xf1, 0x7, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xa0, 0x1, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x20, 0x0, 0x7f, 0xff, 0xfc, 0x30, 0x0, 0x1, + 0xaf, 0xff, 0xf7, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xfd, 0xaa, 0xcf, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x9f, 0xff, 0xff, + 0xff, 0xfa, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x36, 0x77, 0x64, 0x0, 0x0, 0x0, 0x0, + + /* U+0036 "6" */ + 0x0, 0x0, 0x0, 0x0, 0x5b, 0xdf, 0xfe, 0xb7, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfa, 0x53, 0x25, + 0xcf, 0xff, 0xf8, 0x0, 0x0, 0x7, 0xff, 0xfe, + 0x30, 0x0, 0x0, 0x8, 0xff, 0xff, 0x20, 0x0, + 0x1f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x80, 0x0, 0x8f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xd0, 0x0, 0xef, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0xe, 0xed, 0xb0, + 0x3, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf0, 0x0, 0x39, 0xdf, 0xfe, + 0xb6, 0x10, 0x0, 0x0, 0xf, 0xff, 0xc0, 0x1a, + 0xff, 0xff, 0xff, 0xff, 0xe6, 0x0, 0x0, 0xf, + 0xff, 0xb1, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x1f, 0xff, 0xbd, 0xff, 0xfb, 0x76, + 0x7a, 0xff, 0xff, 0xf7, 0x0, 0x2f, 0xff, 0xff, + 0xfc, 0x20, 0x0, 0x0, 0x2c, 0xff, 0xff, 0x30, + 0x2f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xb0, 0x2f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf1, 0x1f, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf5, 0xf, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xf8, 0xf, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf9, 0xc, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf9, 0xa, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xf8, 0x6, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf5, + 0x1, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xf1, 0x0, 0xbf, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xb0, 0x0, 0x3f, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x40, 0x0, 0x8, 0xff, 0xff, 0x91, 0x0, 0x0, + 0x6f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xca, 0xbe, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x19, 0xff, 0xff, + 0xff, 0xfd, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0x67, 0x75, 0x20, 0x0, 0x0, 0x0, + + /* U+0037 "7" */ + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x9d, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0xdf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x88, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xdf, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2e, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0038 "8" */ + 0x0, 0x0, 0x0, 0x6, 0xad, 0xff, 0xec, 0x71, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xef, 0xff, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x10, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xd6, 0x32, 0x4a, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x1f, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf7, 0x0, 0x0, + 0x7f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xfd, 0x0, 0x0, 0xbf, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0x20, 0x0, 0xdf, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x40, + 0x0, 0xdf, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x40, 0x0, 0xbf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x20, 0x0, 0x6f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xfe, + 0x0, 0x0, 0xd, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x3e, 0xff, 0xf6, 0x0, 0x0, 0x2, 0xef, 0xff, + 0xc6, 0x22, 0x49, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x1a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x2, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x40, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0x83, 0x0, 0x26, 0xdf, + 0xff, 0xf6, 0x0, 0x0, 0xdf, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0x30, 0x6, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xc0, 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf2, 0xf, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf7, 0x1f, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf9, 0x1f, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xf9, 0xf, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf7, + 0xd, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf5, 0x8, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf0, 0x1, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, + 0x90, 0x0, 0x6f, 0xff, 0xfb, 0x30, 0x0, 0x0, + 0x6f, 0xff, 0xfe, 0x10, 0x0, 0x8, 0xff, 0xff, + 0xfd, 0xba, 0xcf, 0xff, 0xff, 0xe2, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0x10, 0x0, 0x0, 0x0, 0x1, 0x8e, 0xff, 0xff, + 0xff, 0xfc, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x25, 0x77, 0x64, 0x10, 0x0, 0x0, 0x0, + + /* U+0039 "9" */ + 0x0, 0x0, 0x0, 0x27, 0xbe, 0xfe, 0xd9, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x40, 0x0, 0x0, 0x0, 0x1, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xd7, 0x32, 0x49, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x8f, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x2e, 0xff, 0xf5, 0x0, 0x1, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xfe, 0x0, 0x7, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x50, 0xb, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xb0, + 0xf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xf0, 0xf, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xf2, 0x1f, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf5, 0xf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf7, 0xe, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf8, 0xa, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xf9, 0x5, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xf9, 0x0, 0xdf, 0xff, + 0xe3, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf9, + 0x0, 0x4f, 0xff, 0xff, 0x93, 0x0, 0x26, 0xdf, + 0xfc, 0xff, 0xf9, 0x0, 0x6, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc4, 0xff, 0xf8, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x4, 0xff, + 0xf7, 0x0, 0x0, 0x1, 0x9e, 0xff, 0xff, 0xfb, + 0x30, 0x6, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x34, 0x54, 0x10, 0x0, 0x8, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xd0, 0x2, 0x57, 0x82, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x90, + 0x5, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x30, 0x2, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xfd, 0x0, 0x0, 0xcf, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf4, + 0x0, 0x0, 0x4f, 0xff, 0xf7, 0x0, 0x0, 0x6, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xeb, 0xac, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xcf, 0xff, 0xff, + 0xff, 0xa3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x57, 0x76, 0x40, 0x0, 0x0, 0x0, 0x0, + + /* U+003A ":" */ + 0x1f, 0xff, 0xf5, 0x1f, 0xff, 0xf5, 0x1f, 0xff, + 0xf5, 0x1f, 0xff, 0xf5, 0x5, 0x55, 0x51, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0x55, + 0x51, 0x1f, 0xff, 0xf5, 0x1f, 0xff, 0xf5, 0x1f, + 0xff, 0xf5, 0x1f, 0xff, 0xf5, + + /* U+003B ";" */ + 0x2f, 0xff, 0xf3, 0x2f, 0xff, 0xf3, 0x2f, 0xff, + 0xf3, 0x2f, 0xff, 0xf3, 0x5, 0x55, 0x51, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0x55, + 0x51, 0x2f, 0xff, 0xf3, 0x2f, 0xff, 0xf3, 0x2f, + 0xff, 0xf3, 0x2f, 0xff, 0xf3, 0x0, 0xf, 0xf2, + 0x0, 0x2f, 0xf1, 0x0, 0x7f, 0xd0, 0x2, 0xff, + 0x70, 0x3f, 0xfc, 0x0, 0xc, 0x91, 0x0, 0x0, + 0x0, 0x0, + + /* U+003C "<" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x73, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xaf, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xdf, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x29, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5b, 0xff, 0xff, 0xff, 0xfb, 0x40, 0x0, + 0x0, 0x0, 0x1, 0x8e, 0xff, 0xff, 0xff, 0xe8, + 0x10, 0x0, 0x0, 0x0, 0x4, 0xaf, 0xff, 0xff, + 0xff, 0xb5, 0x0, 0x0, 0x0, 0x0, 0x6, 0xdf, + 0xff, 0xff, 0xfe, 0x82, 0x0, 0x0, 0x0, 0x0, + 0x29, 0xff, 0xff, 0xff, 0xfb, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xe8, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xa3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5d, 0xff, 0xff, 0xff, + 0xc6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4b, 0xff, 0xff, 0xff, 0xf9, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x29, 0xff, 0xff, 0xff, + 0xfc, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xdf, 0xff, 0xff, 0xfe, 0x82, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xaf, 0xff, 0xff, + 0xff, 0xb4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x8e, 0xff, 0xff, 0xff, 0xe3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5c, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x39, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x17, 0xd4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+003D "=" */ + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf4, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x8f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf4, 0x48, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, + 0x88, 0x88, 0x88, 0x82, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x49, 0x99, 0x99, 0x99, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x92, 0x8f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf4, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + + /* U+003E ">" */ + 0x66, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xe8, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xfb, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xfd, 0x71, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xcf, 0xff, 0xff, + 0xff, 0xa3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0x9f, 0xff, 0xff, 0xff, 0xc6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x6d, 0xff, 0xff, + 0xff, 0xe8, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3a, 0xff, 0xff, 0xff, 0xfb, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x17, 0xdf, 0xff, + 0xff, 0xfe, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xaf, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xaf, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5b, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x8e, 0xff, 0xff, 0xff, 0xc2, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xbf, 0xff, 0xff, 0xff, + 0x92, 0x0, 0x0, 0x0, 0x0, 0x17, 0xdf, 0xff, + 0xff, 0xfd, 0x71, 0x0, 0x0, 0x0, 0x0, 0x3a, + 0xff, 0xff, 0xff, 0xfb, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x6d, 0xff, 0xff, 0xff, 0xe8, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xd6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xa3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xfe, 0x81, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9c, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+003F "?" */ + 0x0, 0x0, 0x0, 0x3, 0x57, 0x76, 0x41, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x8e, 0xff, 0xff, + 0xff, 0xfc, 0x50, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xc2, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xfd, 0xba, 0xcf, 0xff, 0xff, + 0xe2, 0x0, 0x4, 0xff, 0xff, 0xc3, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xe0, 0x0, 0xdf, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x80, 0x4f, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xfe, 0x9, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf2, 0xcf, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x47, 0x9b, + 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3e, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfe, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfd, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, + 0xff, 0xfc, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xfc, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x46, 0x65, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0x55, 0x52, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + + /* U+0040 "@" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x46, 0x77, 0x76, 0x53, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0x7c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x83, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xbf, 0xff, 0xff, 0xff, + 0xdb, 0xa9, 0xab, 0xdf, 0xff, 0xff, 0xff, 0xb1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xe8, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x48, 0xef, 0xff, 0xfe, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xd5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xef, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xfe, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x2e, 0xff, 0xe3, 0x0, 0x0, 0x0, + 0x2, 0x57, 0x64, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x30, 0x0, 0x0, 0x4, 0xcf, 0xff, 0xff, + 0xe7, 0x0, 0x1f, 0xff, 0xc0, 0x0, 0x6f, 0xff, + 0x40, 0x0, 0x0, 0x5, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x4f, + 0xff, 0x90, 0x0, 0xb, 0xff, 0xc0, 0x0, 0x0, + 0xd, 0xff, 0xa0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xec, 0xbe, 0xff, 0xf9, 0x7f, 0xff, 0x50, 0x0, + 0x3, 0xff, 0xf2, 0x0, 0x0, 0x6f, 0xff, 0x10, + 0x0, 0x0, 0x9f, 0xff, 0xf6, 0x0, 0x0, 0x5f, + 0xff, 0xef, 0xff, 0x20, 0x0, 0x0, 0xcf, 0xf8, + 0x0, 0x0, 0xdf, 0xf8, 0x0, 0x0, 0x5, 0xff, + 0xfe, 0x30, 0x0, 0x0, 0x3, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x7f, 0xfc, 0x0, 0x3, 0xff, + 0xf1, 0x0, 0x0, 0x1e, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x4f, 0xfe, 0x0, 0x8, 0xff, 0xb0, 0x0, 0x0, + 0x9f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x0, + 0xc, 0xff, 0x60, 0x0, 0x1, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x10, 0xf, 0xff, 0x20, + 0x0, 0x7, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0x10, 0x3f, 0xff, 0x0, 0x0, 0xc, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x0, 0x5f, + 0xfd, 0x0, 0x0, 0xf, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x5f, 0xfe, 0x0, 0x6f, 0xfb, 0x0, 0x0, + 0x2f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x9f, 0xfa, + 0x0, 0x7f, 0xfb, 0x0, 0x0, 0x4f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x40, + 0x0, 0x0, 0x0, 0xef, 0xf6, 0x0, 0x7f, 0xfb, + 0x0, 0x0, 0x4f, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf1, 0x0, 0x7f, 0xfc, 0x0, 0x0, 0x4f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0xe, 0xff, 0x90, 0x0, + 0x6f, 0xfd, 0x0, 0x0, 0x2f, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0x20, 0x0, 0x4f, 0xff, 0x0, + 0x0, 0xe, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xf6, 0x0, 0x0, 0x6, 0xff, 0xf7, + 0x0, 0x0, 0x2f, 0xff, 0x30, 0x0, 0x9, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x6f, 0xff, 0xb0, 0x0, 0x0, 0xe, + 0xff, 0x70, 0x0, 0x3, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xf4, 0x0, 0x2b, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0xa, 0xff, 0xc0, 0x0, + 0x0, 0x9f, 0xff, 0xf9, 0x32, 0x5b, 0xff, 0xef, + 0xff, 0xfe, 0x9b, 0xff, 0xff, 0xe2, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf3, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x2c, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x10, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xfb, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, + 0xa1, 0x4, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x50, 0x0, + 0x0, 0x4, 0xbe, 0xfd, 0xa4, 0x0, 0x0, 0x4c, + 0xef, 0xeb, 0x60, 0x0, 0x0, 0x6, 0x77, 0x70, + 0x0, 0xd, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x90, 0x0, 0x4, 0xff, + 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x7f, 0xff, 0xd3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2b, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xfe, 0x71, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x29, 0xff, 0xff, 0xe3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, + 0xc7, 0x30, 0x0, 0x0, 0x0, 0x0, 0x2, 0x7b, + 0xff, 0xff, 0xfb, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1a, 0xff, 0xff, 0xff, 0xff, 0xec, + 0xba, 0xaa, 0xbd, 0xff, 0xff, 0xff, 0xfe, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0x9d, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd9, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x46, 0x77, + 0x76, 0x65, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0041 "A" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xdf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xe6, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xfa, 0x1f, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x60, 0xaf, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf1, 0x5, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xfb, 0x0, 0xe, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x50, 0x0, 0x8f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xe0, 0x0, 0x2, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xf9, 0x0, 0x0, 0xc, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x30, 0x0, 0x0, 0x6f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xfd, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x5e, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x7, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xf2, 0x0, 0x0, 0x4f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0x90, 0x0, 0xa, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0x0, 0x1, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xf6, 0x0, 0x6f, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xd0, 0xd, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x30, + + /* U+0042 "B" */ + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xda, + 0x71, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x10, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x30, 0x0, 0xc, 0xff, 0xfc, + 0xaa, 0xaa, 0xaa, 0xab, 0xdf, 0xff, 0xff, 0xfe, + 0x20, 0x0, 0xcf, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x3, 0x9f, 0xff, 0xfb, 0x0, 0xc, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xf1, 0x0, 0xcf, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x50, 0xc, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf7, 0x0, 0xcf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x70, + 0xc, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf5, 0x0, 0xcf, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0x10, 0xc, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x80, 0x0, 0xcf, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x2, 0x48, 0xef, 0xff, + 0xc0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0xcf, 0xff, 0xca, 0xaa, 0xaa, 0xaa, 0xbb, 0xdf, + 0xff, 0xff, 0xfb, 0x0, 0xc, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xcf, 0xff, 0xf9, + 0x0, 0xcf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xf3, 0xc, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xa0, 0xcf, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xfe, 0xc, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xf0, 0xcf, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xc, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xe0, 0xcf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xfa, + 0xc, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0x50, 0xcf, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4b, 0xff, 0xff, + 0xd0, 0xc, 0xff, 0xfc, 0xaa, 0xaa, 0xaa, 0xaa, + 0xbd, 0xff, 0xff, 0xff, 0xf3, 0x0, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf4, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xa1, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xec, 0x96, + 0x10, 0x0, 0x0, 0x0, + + /* U+0043 "C" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x46, 0x77, + 0x64, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0x9e, 0xff, 0xff, 0xff, 0xff, + 0xd7, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xe9, + 0x42, 0x10, 0x14, 0x9f, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x2c, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x2f, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0x40, 0x0, 0xb, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xfc, 0x0, 0x3, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xf3, 0x0, 0xaf, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfc, + 0x40, 0xf, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0x30, 0x0, 0x3, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2b, 0x73, 0x0, 0xd, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xfe, 0x0, 0x7f, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xa0, 0x1, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf4, 0x0, 0x9, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfd, + 0x0, 0x0, 0x1e, 0xff, 0xfe, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x5f, 0xff, 0xfe, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x3d, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xd8, 0x31, 0x1, 0x26, 0xcf, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4d, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xd7, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x57, 0x77, + 0x64, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0044 "D" */ + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xdc, + 0x96, 0x10, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa2, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x8, 0xff, 0xfd, 0xaa, 0xaa, 0xaa, 0xab, 0xcd, + 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x8f, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4b, 0xff, + 0xff, 0xf4, 0x0, 0x8, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xe1, + 0x0, 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0x90, 0x8, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0x10, 0x8f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xf7, 0x8, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xc0, 0x8f, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0x8, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xf3, 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x58, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf6, 0x8f, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x78, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf7, + 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x78, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xf6, 0x8f, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0x48, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf1, 0x8f, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xfe, 0x8, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xa0, 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf5, 0x8, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xfe, 0x0, 0x8f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x70, 0x8, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xd0, 0x0, 0x8f, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x5c, + 0xff, 0xff, 0xf3, 0x0, 0x8, 0xff, 0xfe, 0xaa, + 0xaa, 0xaa, 0xab, 0xce, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe3, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x81, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0xdb, 0x84, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+0045 "E" */ + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x8f, 0xff, 0xea, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xa2, + 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x10, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x10, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x10, + 0x8f, 0xff, 0xea, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0x0, 0x8f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xea, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, + + /* U+0046 "F" */ + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x7f, 0xff, 0xea, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xa8, 0x7f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xea, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xa4, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf7, 0x0, 0x7f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf7, 0x0, 0x7f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0047 "G" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x35, 0x67, + 0x76, 0x52, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x30, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, + 0xff, 0xfb, 0x73, 0x21, 0x1, 0x47, 0xdf, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x1, 0xef, 0xff, 0xfb, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x5, 0xef, 0xff, + 0xf2, 0x0, 0x0, 0xc, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, 0xfb, + 0x0, 0x0, 0x6f, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x30, + 0x0, 0xef, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x90, 0x6, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x90, 0xc, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0x30, 0x0, 0x1f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0xbf, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0xaf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf6, 0x8f, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9a, 0xaa, 0xaa, + 0xaa, 0xae, 0xff, 0xf6, 0x5f, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf6, 0x2f, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf6, 0xd, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf6, 0x7, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf6, + 0x0, 0xef, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf6, 0x0, + 0x7f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf6, 0x0, 0xc, + 0xff, 0xff, 0xb1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xdf, 0xff, 0xf6, 0x0, 0x1, 0xdf, + 0xff, 0xfe, 0x70, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xbf, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x2d, 0xff, + 0xff, 0xff, 0xb7, 0x54, 0x34, 0x6a, 0xef, 0xff, + 0xff, 0xfe, 0x50, 0x0, 0x0, 0x1, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xa1, 0x0, 0x0, 0x0, 0x0, 0x5, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xae, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x72, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x24, 0x67, + 0x77, 0x53, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0048 "H" */ + 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf3, 0x7f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf3, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, 0x7f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf3, 0x7f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf3, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, 0x7f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf3, 0x7f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, + 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf3, 0x7f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf3, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, 0x7f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf3, 0x7f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf3, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf3, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, + 0x7f, 0xff, 0xea, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaf, 0xff, 0xf3, 0x7f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf3, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, 0x7f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf3, 0x7f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf3, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, 0x7f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf3, 0x7f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, + 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf3, 0x7f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf3, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, 0x7f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf3, 0x7f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf3, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, 0x7f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf3, + + /* U+0049 "I" */ + 0xff, 0xff, 0x3f, 0xff, 0xf3, 0xff, 0xff, 0x3f, + 0xff, 0xf3, 0xff, 0xff, 0x3f, 0xff, 0xf3, 0xff, + 0xff, 0x3f, 0xff, 0xf3, 0xff, 0xff, 0x3f, 0xff, + 0xf3, 0xff, 0xff, 0x3f, 0xff, 0xf3, 0xff, 0xff, + 0x3f, 0xff, 0xf3, 0xff, 0xff, 0x3f, 0xff, 0xf3, + 0xff, 0xff, 0x3f, 0xff, 0xf3, 0xff, 0xff, 0x3f, + 0xff, 0xf3, 0xff, 0xff, 0x3f, 0xff, 0xf3, 0xff, + 0xff, 0x3f, 0xff, 0xf3, 0xff, 0xff, 0x3f, 0xff, + 0xf3, 0xff, 0xff, 0x3f, 0xff, 0xf3, 0xff, 0xff, + 0x3f, 0xff, 0xf3, 0xff, 0xff, 0x30, + + /* U+004A "J" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf9, 0x0, 0x24, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf8, 0xaf, 0xff, + 0x10, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf7, 0xaf, + 0xff, 0x30, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, + 0x9f, 0xff, 0x60, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xf4, 0x6f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf1, 0x2f, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xd0, 0xb, 0xff, 0xff, 0xb5, 0x33, + 0x6d, 0xff, 0xff, 0x60, 0x2, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb1, 0x0, 0x0, 0x2, + 0xaf, 0xff, 0xff, 0xff, 0xd5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x46, 0x77, 0x52, 0x0, 0x0, 0x0, + + /* U+004B "K" */ + 0xcf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xf3, 0xc, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xe3, 0x0, 0xcf, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xe2, 0x0, + 0xc, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xe2, 0x0, 0x0, 0xcf, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xd1, 0x0, 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xd1, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x60, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x60, 0x0, 0xa, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf6, 0x0, + 0xa, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x60, 0xa, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf6, 0xa, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x6a, + 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xfe, 0xff, 0xff, 0x9f, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0x50, 0x9f, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0x40, 0x0, 0xdf, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x40, 0x0, + 0x2, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0x30, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf6, 0x0, + 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xf3, 0x0, 0x0, 0xcf, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xd0, 0x0, 0xc, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xa0, 0x0, 0xcf, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0x60, 0xc, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0x30, 0xcf, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xfd, 0x0, + + /* U+004C "L" */ + 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xda, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + + /* U+004D "M" */ + 0xbf, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x5b, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf5, 0xbf, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x5b, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf5, 0xbf, 0xff, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xff, 0x5b, 0xff, 0xfb, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xfd, 0xff, 0xf5, 0xbf, 0xff, 0x6f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xfd, 0xaf, 0xff, 0x5b, 0xff, 0xf5, 0xaf, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0x7a, 0xff, 0xf5, 0xbf, 0xff, 0x55, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf2, 0xaf, 0xff, 0x5b, 0xff, 0xf5, 0xf, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfc, + 0xa, 0xff, 0xf5, 0xbf, 0xff, 0x50, 0xaf, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0x60, + 0xaf, 0xff, 0x5b, 0xff, 0xf5, 0x4, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf1, 0xa, + 0xff, 0xf5, 0xbf, 0xff, 0x50, 0xe, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfb, 0x0, 0xaf, + 0xff, 0x5b, 0xff, 0xf5, 0x0, 0x9f, 0xff, 0x20, + 0x0, 0x0, 0x0, 0xe, 0xff, 0x50, 0xa, 0xff, + 0xf5, 0xbf, 0xff, 0x50, 0x4, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xf0, 0x0, 0xaf, 0xff, + 0x5b, 0xff, 0xf5, 0x0, 0xe, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0xaf, 0xfa, 0x0, 0xa, 0xff, 0xf5, + 0xbf, 0xff, 0x50, 0x0, 0x9f, 0xff, 0x20, 0x0, + 0x0, 0xf, 0xff, 0x40, 0x0, 0xaf, 0xff, 0x5b, + 0xff, 0xf5, 0x0, 0x3, 0xff, 0xf8, 0x0, 0x0, + 0x5, 0xff, 0xe0, 0x0, 0xa, 0xff, 0xf5, 0xbf, + 0xff, 0x50, 0x0, 0xd, 0xff, 0xd0, 0x0, 0x0, + 0xbf, 0xf9, 0x0, 0x0, 0xaf, 0xff, 0x5b, 0xff, + 0xf5, 0x0, 0x0, 0x8f, 0xff, 0x30, 0x0, 0x1f, + 0xff, 0x40, 0x0, 0xa, 0xff, 0xf5, 0xbf, 0xff, + 0x50, 0x0, 0x3, 0xff, 0xf8, 0x0, 0x6, 0xff, + 0xe0, 0x0, 0x0, 0xaf, 0xff, 0x5b, 0xff, 0xf5, + 0x0, 0x0, 0xd, 0xff, 0xd0, 0x0, 0xcf, 0xf8, + 0x0, 0x0, 0xa, 0xff, 0xf5, 0xbf, 0xff, 0x50, + 0x0, 0x0, 0x7f, 0xff, 0x30, 0x1f, 0xff, 0x30, + 0x0, 0x0, 0xaf, 0xff, 0x5b, 0xff, 0xf5, 0x0, + 0x0, 0x2, 0xff, 0xf8, 0x7, 0xff, 0xd0, 0x0, + 0x0, 0xa, 0xff, 0xf5, 0xbf, 0xff, 0x50, 0x0, + 0x0, 0xc, 0xff, 0xd0, 0xcf, 0xf7, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0x5b, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x5f, 0xff, 0x20, 0x0, 0x0, + 0xa, 0xff, 0xf5, 0xbf, 0xff, 0x50, 0x0, 0x0, + 0x1, 0xff, 0xfe, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x5b, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf5, 0xbf, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0x5b, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf5, 0xbf, 0xff, 0x50, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x50, + + /* U+004E "N" */ + 0x8f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf4, 0x8f, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xf4, 0x8f, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf4, 0x8f, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf4, 0x8f, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf4, 0x8f, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xf4, 0x8f, 0xff, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf4, 0x8f, 0xff, 0x8e, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf4, + 0x8f, 0xff, 0x74, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf4, 0x8f, 0xff, 0x70, + 0x9f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xf4, 0x8f, 0xff, 0x70, 0xd, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf4, 0x8f, + 0xff, 0x70, 0x3, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf4, 0x8f, 0xff, 0x70, 0x0, + 0x8f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf4, 0x8f, 0xff, 0x70, 0x0, 0xd, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xf4, 0x8f, 0xff, + 0x70, 0x0, 0x3, 0xff, 0xff, 0x90, 0x0, 0x0, + 0xb, 0xff, 0xf4, 0x8f, 0xff, 0x70, 0x0, 0x0, + 0x8f, 0xff, 0xf4, 0x0, 0x0, 0xb, 0xff, 0xf4, + 0x8f, 0xff, 0x70, 0x0, 0x0, 0xc, 0xff, 0xfe, + 0x10, 0x0, 0xb, 0xff, 0xf4, 0x8f, 0xff, 0x70, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xa0, 0x0, 0xb, + 0xff, 0xf4, 0x8f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xf5, 0x0, 0xb, 0xff, 0xf4, 0x8f, + 0xff, 0x70, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfe, + 0x10, 0xb, 0xff, 0xf4, 0x8f, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xa0, 0xb, 0xff, + 0xf4, 0x8f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xf5, 0xb, 0xff, 0xf4, 0x8f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xfe, + 0x1b, 0xff, 0xf4, 0x8f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xbb, 0xff, 0xf4, + 0x8f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xf4, 0x8f, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xf4, 0x8f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xf4, 0x8f, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xf4, 0x8f, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xf4, 0x8f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xf4, 0x8f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xf4, + + /* U+004F "O" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x46, 0x77, + 0x65, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0x8d, 0xff, 0xff, 0xff, + 0xff, 0xea, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x19, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xfa, 0x53, 0x11, 0x24, 0x9e, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0x91, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xef, 0xff, 0xf4, 0x0, 0x0, 0xb, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xe0, 0x0, 0x3, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0x70, 0x0, 0xaf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfe, 0x0, 0xf, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf4, 0x4, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x90, 0x8f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xfc, 0xb, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xf0, 0xdf, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0x1e, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf2, + 0xef, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x2e, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf2, 0xdf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x1b, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf0, 0x8f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xfc, 0x4, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x90, 0xf, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xf4, 0x0, 0x9f, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xfe, 0x0, 0x3, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0x70, 0x0, 0xa, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xff, 0xe0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xdf, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xef, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xe9, + 0x42, 0x10, 0x24, 0x8d, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x18, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x7d, 0xff, 0xff, + 0xff, 0xff, 0xe9, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x46, 0x77, + 0x75, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0050 "P" */ + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xed, + 0xb9, 0x50, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x0, 0x9, 0xff, 0xfd, + 0xaa, 0xaa, 0xaa, 0xaa, 0xab, 0xcf, 0xff, 0xff, + 0xfa, 0x0, 0x9f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xef, 0xff, 0xf5, 0x9, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xc0, 0x9f, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x19, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf4, 0x9f, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x69, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf6, 0x9f, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0x59, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf2, 0x9f, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfd, 0x9, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x70, 0x9f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x14, 0x8e, + 0xff, 0xff, 0xd0, 0x9, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe3, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x70, 0x0, + 0x0, 0x9f, 0xff, 0xda, 0xaa, 0xaa, 0xaa, 0xaa, + 0x98, 0x52, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0051 "Q" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x46, 0x77, + 0x65, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0x8e, 0xff, 0xff, 0xff, + 0xff, 0xe9, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1a, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xfa, 0x53, 0x11, 0x24, 0x8d, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0x91, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xef, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xdf, 0xff, 0xf4, 0x0, 0x0, 0xa, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xd0, 0x0, 0x3, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0x60, 0x0, 0xaf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfd, 0x0, 0xf, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf3, 0x5, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x80, 0x8f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xfc, 0xb, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xf0, 0xdf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x1e, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf2, + 0xef, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x2d, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf2, 0xcf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x1b, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf0, 0x7f, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xfc, 0x3, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x90, 0xf, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf4, 0x0, 0x9f, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0x30, 0x0, 0x0, + 0xa, 0xff, 0xfe, 0x0, 0x1, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xd6, 0x0, 0x3, + 0xff, 0xff, 0x70, 0x0, 0x9, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xfd, 0x31, 0xef, + 0xff, 0xe0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x5, 0xcf, 0xff, 0xff, 0xdf, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0x81, + 0x0, 0x0, 0x0, 0x2b, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xe9, + 0x52, 0x10, 0x24, 0x9f, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4e, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x1a, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xbf, 0xff, 0xff, 0x81, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x9e, 0xff, 0xff, + 0xff, 0xff, 0xe9, 0x30, 0x2c, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x46, 0x77, + 0x65, 0x20, 0x0, 0x0, 0x7, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x8e, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x0, + + /* U+0052 "R" */ + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xed, 0xb8, 0x40, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd4, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x7, 0xff, 0xfd, 0x66, 0x66, + 0x66, 0x66, 0x66, 0x78, 0xbf, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x19, 0xff, 0xff, 0xc0, 0x0, + 0x7, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0x30, 0x0, 0x7f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf8, 0x0, 0x7, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xa0, 0x0, 0x7f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xfa, 0x0, 0x7, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x90, + 0x0, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf6, 0x0, 0x7, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0x10, 0x0, 0x7f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5d, + 0xff, 0xff, 0x80, 0x0, 0x7, 0xff, 0xfd, 0x88, + 0x88, 0x88, 0x88, 0x89, 0xac, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x40, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x51, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x37, 0xdf, 0xff, 0xe5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x7, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x7f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x20, 0x0, 0x7, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xfc, 0x0, + 0x0, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf6, 0x0, 0x7, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xf1, 0x0, 0x7f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xa0, 0x7, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0x50, 0x7f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xfe, 0x0, + + /* U+0053 "S" */ + 0x0, 0x0, 0x0, 0x0, 0x1, 0x46, 0x77, 0x65, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6c, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd3, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xfb, 0x64, 0x22, 0x24, 0x7d, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0xef, 0xff, 0xc2, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x5f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x60, 0x0, 0xa, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xfb, 0x0, 0x0, 0xcf, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xe0, 0x0, 0xc, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xdc, 0x0, 0x0, + 0xaf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xd7, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0xd9, 0x51, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x95, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1a, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0x8d, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x6a, 0xef, 0xff, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x16, 0xae, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xbf, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xf9, 0x0, 0x1, 0x34, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xd0, 0xf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x0, 0xdf, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf0, 0xa, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xfe, 0x0, 0x5f, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xb0, 0x0, + 0xef, 0xff, 0xe4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf6, 0x0, 0x5, 0xff, 0xff, + 0xf9, 0x10, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xfd, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xb7, + 0x43, 0x34, 0x69, 0xef, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x4, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5b, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x25, 0x67, 0x76, + 0x53, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0054 "T" */ + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0xf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xae, 0xff, 0xfd, 0xaa, + 0xaa, 0xaa, 0xaa, 0xa9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+0055 "U" */ + 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf4, 0x8f, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf4, 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf4, 0x8f, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf4, 0x8f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xf4, 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xf4, 0x8f, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xf4, 0x8f, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf4, + 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf4, 0x8f, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf4, 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf4, 0x8f, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf4, 0x8f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xf4, 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xf4, 0x8f, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xf4, 0x8f, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf4, + 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf4, 0x7f, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf4, 0x7f, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf4, 0x6f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf3, 0x5f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf2, 0x4f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf1, 0x1f, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xe0, 0xe, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, + 0x9, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0x70, 0x3, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0x10, 0x0, 0xcf, 0xff, 0xf9, 0x10, 0x0, + 0x0, 0x0, 0x2, 0xbf, 0xff, 0xf9, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xfb, 0x64, 0x34, 0x57, 0xbf, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x20, + 0x0, 0x0, 0x0, 0x3e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xa1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5c, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x92, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0x56, 0x77, 0x65, 0x20, 0x0, 0x0, 0x0, 0x0, + + /* U+0056 "V" */ + 0x9f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x3f, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0x60, 0xc, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0x10, 0x6, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xfa, 0x0, 0x0, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf3, 0x0, 0x0, 0x9f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xd0, 0x0, 0x0, 0x3f, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, + 0x0, 0x0, 0xd, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x7, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xf7, 0x0, 0x0, 0x3, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xfc, 0x0, 0x0, 0x9, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x20, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0x80, 0x0, 0x5f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xe0, 0x0, 0xbf, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf3, + 0x1, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf9, 0x6, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfe, 0xb, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x5f, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xef, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+0057 "W" */ + 0x6f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xc2, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf8, 0xd, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x40, 0x9f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xf0, 0x5, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0x9f, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xfb, 0x0, 0x1f, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xf3, 0xdf, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0x60, 0x0, 0xcf, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0x9, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf2, 0x0, + 0x8, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xb0, 0x5f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xfd, 0x0, 0x0, 0x4f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf6, 0x0, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x90, + 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x20, 0xc, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf4, 0x0, 0x0, 0xb, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0xb, 0xff, 0xd0, 0x0, + 0x7f, 0xff, 0x40, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0xff, 0xf9, 0x0, 0x3, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xb0, 0x0, 0x0, 0x2, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x40, + 0x0, 0xe, 0xff, 0xe0, 0x0, 0x0, 0x5, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0xe, 0xff, 0xe0, 0x0, + 0x0, 0x9, 0xff, 0xf0, 0x0, 0x0, 0xaf, 0xff, + 0x20, 0x0, 0x0, 0x9f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0x20, 0x0, 0x0, 0xef, 0xfb, + 0x0, 0x0, 0x5, 0xff, 0xf7, 0x0, 0x0, 0xd, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf6, + 0x0, 0x0, 0x2f, 0xff, 0x70, 0x0, 0x0, 0x1f, + 0xff, 0xb0, 0x0, 0x1, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x90, 0x0, 0x7, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x0, 0x0, + 0x5f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xfd, 0x0, 0x0, 0xcf, 0xfe, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xf4, 0x0, 0x9, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xf1, 0x0, 0xf, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x80, + 0x0, 0xdf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x50, 0x5, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xfc, 0x0, 0x1f, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf8, 0x0, + 0x9f, 0xff, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf0, 0x5, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xc0, 0xe, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x40, 0x9f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0x1, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xf7, 0xc, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf3, 0x5f, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xa0, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0x69, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xfd, 0x4f, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf9, 0xdf, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf8, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xef, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xef, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, + + /* U+0058 "X" */ + 0x1, 0xef, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xfc, 0x0, 0x0, + 0x4f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xe2, 0x0, 0x0, 0x8, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfe, 0x10, + 0x0, 0x2, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xb0, 0x0, + 0xd, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf6, 0x0, 0x9f, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0x15, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xbe, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0x4e, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf9, 0x5, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xd0, 0x0, 0xaf, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0x30, 0x0, 0xd, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf6, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0x80, 0x0, 0x0, 0xdf, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf4, 0x0, 0xa, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xfe, 0x10, 0x6f, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xb0, + + /* U+0059 "Y" */ + 0x8f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xa0, 0xdf, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xe1, 0x3, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xf4, 0x0, 0x8, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf8, 0x0, 0x0, 0xc, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x3f, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x20, + 0x0, 0xd, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfc, 0x0, 0x7, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xf6, 0x2, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xe0, 0xbf, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xcf, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+005A "Z" */ + 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x6f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0x3a, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xfd, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, + 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1d, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xfe, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xa7, 0x3f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfb, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, + + /* U+005B "[" */ + 0x1f, 0xff, 0xff, 0xff, 0xf7, 0x1f, 0xff, 0xff, + 0xff, 0xf7, 0x1f, 0xff, 0xff, 0xff, 0xf7, 0x1f, + 0xff, 0xd2, 0x22, 0x21, 0x1f, 0xff, 0xc0, 0x0, + 0x0, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x1f, 0xff, + 0xc0, 0x0, 0x0, 0x1f, 0xff, 0xc0, 0x0, 0x0, + 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x1f, 0xff, 0xc0, + 0x0, 0x0, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x1f, + 0xff, 0xc0, 0x0, 0x0, 0x1f, 0xff, 0xc0, 0x0, + 0x0, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x1f, 0xff, + 0xc0, 0x0, 0x0, 0x1f, 0xff, 0xc0, 0x0, 0x0, + 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x1f, 0xff, 0xc0, + 0x0, 0x0, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x1f, + 0xff, 0xc0, 0x0, 0x0, 0x1f, 0xff, 0xc0, 0x0, + 0x0, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x1f, 0xff, + 0xc0, 0x0, 0x0, 0x1f, 0xff, 0xc0, 0x0, 0x0, + 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x1f, 0xff, 0xc0, + 0x0, 0x0, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x1f, + 0xff, 0xc0, 0x0, 0x0, 0x1f, 0xff, 0xc0, 0x0, + 0x0, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x1f, 0xff, + 0xc0, 0x0, 0x0, 0x1f, 0xff, 0xc0, 0x0, 0x0, + 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x1f, 0xff, 0xc0, + 0x0, 0x0, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x1f, + 0xff, 0xc0, 0x0, 0x0, 0x1f, 0xff, 0xd2, 0x22, + 0x21, 0x1f, 0xff, 0xff, 0xff, 0xf7, 0x1f, 0xff, + 0xff, 0xff, 0xf7, 0x1f, 0xff, 0xff, 0xff, 0xf7, + + /* U+005C "\\" */ + 0xdf, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf1, + + /* U+005D "]" */ + 0x3f, 0xff, 0xff, 0xff, 0xf4, 0x3f, 0xff, 0xff, + 0xff, 0xf4, 0x3f, 0xff, 0xff, 0xff, 0xf4, 0x2, + 0x22, 0x2a, 0xff, 0xf4, 0x0, 0x0, 0x9, 0xff, + 0xf4, 0x0, 0x0, 0x9, 0xff, 0xf4, 0x0, 0x0, + 0x9, 0xff, 0xf4, 0x0, 0x0, 0x9, 0xff, 0xf4, + 0x0, 0x0, 0x9, 0xff, 0xf4, 0x0, 0x0, 0x9, + 0xff, 0xf4, 0x0, 0x0, 0x9, 0xff, 0xf4, 0x0, + 0x0, 0x9, 0xff, 0xf4, 0x0, 0x0, 0x9, 0xff, + 0xf4, 0x0, 0x0, 0x9, 0xff, 0xf4, 0x0, 0x0, + 0x9, 0xff, 0xf4, 0x0, 0x0, 0x9, 0xff, 0xf4, + 0x0, 0x0, 0x9, 0xff, 0xf4, 0x0, 0x0, 0x9, + 0xff, 0xf4, 0x0, 0x0, 0x9, 0xff, 0xf4, 0x0, + 0x0, 0x9, 0xff, 0xf4, 0x0, 0x0, 0x9, 0xff, + 0xf4, 0x0, 0x0, 0x9, 0xff, 0xf4, 0x0, 0x0, + 0x9, 0xff, 0xf4, 0x0, 0x0, 0x9, 0xff, 0xf4, + 0x0, 0x0, 0x9, 0xff, 0xf4, 0x0, 0x0, 0x9, + 0xff, 0xf4, 0x0, 0x0, 0x9, 0xff, 0xf4, 0x0, + 0x0, 0x9, 0xff, 0xf4, 0x0, 0x0, 0x9, 0xff, + 0xf4, 0x0, 0x0, 0x9, 0xff, 0xf4, 0x0, 0x0, + 0x9, 0xff, 0xf4, 0x0, 0x0, 0x9, 0xff, 0xf4, + 0x0, 0x0, 0x9, 0xff, 0xf4, 0x0, 0x0, 0x9, + 0xff, 0xf4, 0x0, 0x0, 0x9, 0xff, 0xf4, 0x0, + 0x0, 0x9, 0xff, 0xf4, 0x2, 0x22, 0x2a, 0xff, + 0xf4, 0x3f, 0xff, 0xff, 0xff, 0xf4, 0x3f, 0xff, + 0xff, 0xff, 0xf4, 0x3f, 0xff, 0xff, 0xff, 0xf4, + + /* U+005E "^" */ + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xfd, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xfd, 0x3f, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x60, 0xcf, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf0, 0x6, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf9, + 0x0, 0xe, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x30, 0x0, 0x8f, 0xff, 0x20, 0x0, 0x0, + 0xe, 0xff, 0xc0, 0x0, 0x2, 0xff, 0xf9, 0x0, + 0x0, 0x6, 0xff, 0xf6, 0x0, 0x0, 0xb, 0xff, + 0xf1, 0x0, 0x0, 0xdf, 0xfe, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x70, 0x0, 0x4f, 0xff, 0x90, 0x0, + 0x0, 0x0, 0xdf, 0xfe, 0x0, 0xb, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf5, 0x2, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xc0, + 0x9f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x40, + + /* U+005F "_" */ + 0x3c, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, + 0xcc, 0xcc, 0xcc, 0xcc, 0xc8, 0x4f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, + + /* U+0060 "`" */ + 0xa, 0xee, 0xee, 0x40, 0x0, 0xd, 0xff, 0xfc, + 0x0, 0x0, 0x2e, 0xff, 0xf4, 0x0, 0x0, 0x3f, + 0xff, 0xc0, 0x0, 0x0, 0x6f, 0xff, 0x40, 0x0, + 0x0, 0x8f, 0xfb, + + /* U+0061 "a" */ + 0x0, 0x0, 0x0, 0x0, 0x36, 0x77, 0x76, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xb4, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xfc, 0xaa, 0xce, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x8f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x4e, 0xff, 0xfe, 0x0, 0x1, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x30, 0x6, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x50, 0x5, 0xbd, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x14, 0xbf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x14, 0x68, 0xad, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x5, 0xae, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x6, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0xcf, 0xff, 0x70, 0x0, + 0xaf, 0xff, 0xff, 0xff, 0xeb, 0x85, 0x10, 0x7f, + 0xff, 0x70, 0x6, 0xff, 0xff, 0xe8, 0x41, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x70, 0xe, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x70, + 0x2f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x70, 0x4f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0x70, 0x4f, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x80, 0x2f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0x80, 0xc, 0xff, 0xfe, 0x30, + 0x0, 0x0, 0x29, 0xff, 0xff, 0xff, 0x90, 0x4, + 0xff, 0xff, 0xfc, 0x98, 0xac, 0xff, 0xff, 0x8f, + 0xff, 0xc0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd3, 0xe, 0xff, 0xf1, 0x0, 0x3, 0xbf, + 0xff, 0xff, 0xff, 0xc5, 0x0, 0x8, 0xff, 0xf7, + 0x0, 0x0, 0x1, 0x57, 0x76, 0x41, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+0062 "b" */ + 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xfd, 0x0, 0x1, 0x57, 0x75, + 0x20, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x1a, + 0xff, 0xff, 0xff, 0xd6, 0x0, 0x0, 0x0, 0xff, + 0xfd, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x10, + 0x0, 0xf, 0xff, 0xef, 0xff, 0xfc, 0xab, 0xef, + 0xff, 0xfc, 0x0, 0x0, 0xff, 0xff, 0xff, 0xb1, + 0x0, 0x0, 0x5f, 0xff, 0xf9, 0x0, 0xf, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf3, + 0x0, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xb0, 0xf, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0x10, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf5, + 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x80, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xfa, 0xf, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xb0, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xfb, 0xf, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xa0, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf9, 0xf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0x70, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf3, 0xf, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xfe, 0x0, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x80, 0xf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xf1, 0x0, 0xff, 0xff, 0xff, 0x91, + 0x0, 0x0, 0x8f, 0xff, 0xf6, 0x0, 0xf, 0xff, + 0xbf, 0xff, 0xfc, 0xab, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0xff, 0xf8, 0x4f, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0xf, 0xff, 0x80, 0x2b, 0xff, + 0xff, 0xff, 0xb3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x57, 0x75, 0x10, 0x0, 0x0, 0x0, + + /* U+0063 "c" */ + 0x0, 0x0, 0x0, 0x0, 0x35, 0x77, 0x63, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xef, 0xff, + 0xff, 0xfe, 0x91, 0x0, 0x0, 0x0, 0x0, 0x4e, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xeb, 0xac, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x2f, 0xff, 0xfd, 0x30, 0x0, + 0x1, 0xbf, 0xff, 0xf1, 0x0, 0xc, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x80, 0x3, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xfe, 0x0, 0x9f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xd1, 0xd, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x22, 0x0, 0x0, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x42, 0x0, + 0xd, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x70, 0x9f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xf4, 0x2, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfe, 0x0, + 0xb, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x80, 0x0, 0x2f, 0xff, 0xfb, 0x20, 0x0, + 0x2, 0xbf, 0xff, 0xe0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xdb, 0xac, 0xff, 0xff, 0xe3, 0x0, 0x0, + 0x0, 0x4e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd2, + 0x0, 0x0, 0x0, 0x0, 0x18, 0xef, 0xff, 0xff, + 0xfe, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x35, 0x77, 0x63, 0x0, 0x0, 0x0, 0x0, + + /* U+0064 "d" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x15, 0x67, 0x52, + 0x0, 0x7, 0xff, 0xf6, 0x0, 0x0, 0x3, 0xbf, + 0xff, 0xff, 0xfd, 0x40, 0x7f, 0xff, 0x60, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0x87, 0xff, + 0xf6, 0x0, 0x8, 0xff, 0xff, 0xfc, 0xac, 0xff, + 0xff, 0xdf, 0xff, 0x60, 0x4, 0xff, 0xff, 0xa1, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf6, 0x0, 0xdf, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0x60, 0x5f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xf6, 0xb, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0x60, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf6, + 0x2f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x64, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xf6, 0x5f, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x66, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xf6, 0x5f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x64, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, 0x2f, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x60, 0xef, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf6, 0xa, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x60, 0x3f, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xf6, 0x0, 0xbf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0x60, 0x2, 0xff, 0xff, 0xb2, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf6, 0x0, 0x5, + 0xff, 0xff, 0xfc, 0xab, 0xef, 0xff, 0xbf, 0xff, + 0x60, 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xa3, 0xff, 0xf6, 0x0, 0x0, 0x1, 0xaf, 0xff, + 0xff, 0xfe, 0x60, 0x3f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x4, 0x67, 0x63, 0x0, 0x0, 0x0, 0x0, + + /* U+0065 "e" */ + 0x0, 0x0, 0x0, 0x0, 0x25, 0x67, 0x64, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6d, 0xff, + 0xff, 0xff, 0xfa, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x2d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x2, 0xef, 0xff, 0xfe, 0xba, 0xcf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0xd, 0xff, 0xfe, + 0x50, 0x0, 0x1, 0x8f, 0xff, 0xf5, 0x0, 0x0, + 0x9f, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xfe, 0x10, 0x1, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x70, 0x7, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xe0, + 0xc, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf2, 0xf, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xf6, 0x2f, 0xff, + 0xf2, 0x22, 0x22, 0x22, 0x22, 0x22, 0x27, 0xff, + 0xf9, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0x4f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x3f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x2f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xfd, 0xb5, 0x2, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xf3, 0x0, 0xbf, 0xff, 0xd1, 0x0, 0x0, 0x0, + 0x1, 0xdf, 0xff, 0xb0, 0x0, 0x1e, 0xff, 0xfe, + 0x50, 0x0, 0x0, 0x4d, 0xff, 0xff, 0x20, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xba, 0xbe, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x3e, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x7d, 0xff, 0xff, 0xff, 0xfe, 0x81, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x25, 0x67, 0x75, 0x20, + 0x0, 0x0, 0x0, + + /* U+0066 "f" */ + 0x0, 0x0, 0x0, 0x2, 0x57, 0x76, 0x41, 0x0, + 0x0, 0x2, 0xcf, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0xff, 0xff, + 0x92, 0x0, 0x20, 0x0, 0x2, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf9, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x0, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x3, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf9, 0x0, 0x0, 0x0, + + /* U+0067 "g" */ + 0x0, 0x0, 0x0, 0x1, 0x46, 0x76, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3b, 0xff, 0xff, + 0xff, 0xe6, 0x0, 0xff, 0xf9, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0xf, 0xff, 0x90, + 0x0, 0x8f, 0xff, 0xff, 0xcb, 0xbe, 0xff, 0xfc, + 0xff, 0xf9, 0x0, 0x5f, 0xff, 0xfa, 0x10, 0x0, + 0x6, 0xff, 0xff, 0xff, 0x90, 0xe, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf9, 0x6, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0x90, 0xcf, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf9, 0xf, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x93, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xf9, 0x6f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x97, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf9, 0x7f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0x96, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xf9, 0x5f, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x92, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf9, + 0xe, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x90, 0x9f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xf9, 0x2, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x90, + 0x9, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xf9, 0x0, 0x1e, 0xff, 0xff, 0x94, 0x23, + 0x7d, 0xff, 0xff, 0xff, 0x90, 0x0, 0x2e, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0xff, 0xf9, 0x0, + 0x0, 0x1b, 0xff, 0xff, 0xff, 0xff, 0xd3, 0x5f, + 0xff, 0x90, 0x0, 0x0, 0x3, 0x9d, 0xef, 0xeb, + 0x60, 0x5, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xf5, 0xa, 0xda, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x20, 0x9f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xe0, 0x5, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf8, + 0x0, 0xe, 0xff, 0xfa, 0x10, 0x0, 0x0, 0x3c, + 0xff, 0xfe, 0x10, 0x0, 0x5f, 0xff, 0xff, 0xdb, + 0xab, 0xef, 0xff, 0xff, 0x40, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x30, 0x0, + 0x0, 0x0, 0x2a, 0xff, 0xff, 0xff, 0xff, 0xd7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x36, 0x77, + 0x75, 0x20, 0x0, 0x0, 0x0, + + /* U+0068 "h" */ + 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xd0, 0x0, 0x3, 0x67, 0x75, 0x20, 0x0, 0x0, + 0xf, 0xff, 0xd0, 0x8, 0xef, 0xff, 0xff, 0xfc, + 0x40, 0x0, 0xf, 0xff, 0xd2, 0xdf, 0xff, 0xff, + 0xff, 0xff, 0xf7, 0x0, 0xf, 0xff, 0xee, 0xff, + 0xff, 0xdd, 0xff, 0xff, 0xff, 0x40, 0xf, 0xff, + 0xff, 0xfc, 0x40, 0x0, 0x6, 0xff, 0xff, 0xb0, + 0xf, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xf1, 0xf, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf4, 0xf, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xf6, 0xf, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf7, + 0xf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf8, 0xf, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf8, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, 0xf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, + 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf8, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf8, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, 0xf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, + 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf8, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf8, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, 0xf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, + 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf8, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf8, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, + + /* U+0069 "i" */ + 0x1f, 0xff, 0xd1, 0xff, 0xfd, 0x1f, 0xff, 0xd1, + 0xff, 0xfd, 0x6, 0x66, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xd1, 0xff, + 0xfd, 0x1f, 0xff, 0xd1, 0xff, 0xfd, 0x1f, 0xff, + 0xd1, 0xff, 0xfd, 0x1f, 0xff, 0xd1, 0xff, 0xfd, + 0x1f, 0xff, 0xd1, 0xff, 0xfd, 0x1f, 0xff, 0xd1, + 0xff, 0xfd, 0x1f, 0xff, 0xd1, 0xff, 0xfd, 0x1f, + 0xff, 0xd1, 0xff, 0xfd, 0x1f, 0xff, 0xd1, 0xff, + 0xfd, 0x1f, 0xff, 0xd1, 0xff, 0xfd, 0x1f, 0xff, + 0xd1, 0xff, 0xfd, 0x1f, 0xff, 0xd0, + + /* U+006A "j" */ + 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, 0xff, + 0xfd, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, + 0xff, 0xfd, 0x0, 0x0, 0x6, 0x66, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xd0, 0x0, 0x0, 0xff, 0xfd, 0x0, 0x0, 0xf, + 0xff, 0xd0, 0x0, 0x0, 0xff, 0xfd, 0x0, 0x0, + 0xf, 0xff, 0xd0, 0x0, 0x0, 0xff, 0xfd, 0x0, + 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, 0xff, 0xfd, + 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, 0xff, + 0xfd, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, + 0xff, 0xfd, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0xff, 0xfd, 0x0, 0x0, 0xf, 0xff, 0xd0, + 0x0, 0x0, 0xff, 0xfd, 0x0, 0x0, 0xf, 0xff, + 0xd0, 0x0, 0x0, 0xff, 0xfd, 0x0, 0x0, 0xf, + 0xff, 0xd0, 0x0, 0x0, 0xff, 0xfd, 0x0, 0x0, + 0xf, 0xff, 0xd0, 0x0, 0x0, 0xff, 0xfd, 0x0, + 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, 0xff, 0xfd, + 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, 0xff, + 0xfc, 0x0, 0x0, 0x2f, 0xff, 0xb0, 0x0, 0x4, + 0xff, 0xf9, 0x0, 0x0, 0xcf, 0xff, 0x65, 0xfe, + 0xff, 0xff, 0xf1, 0x9f, 0xff, 0xff, 0xf9, 0xc, + 0xff, 0xff, 0xf9, 0x0, 0x36, 0x77, 0x51, 0x0, + 0x0, + + /* U+006B "k" */ + 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0x70, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xf6, 0x0, 0x1f, 0xff, 0xc0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0x60, 0x0, 0x1f, 0xff, + 0xc0, 0x0, 0x0, 0x7f, 0xff, 0xf6, 0x0, 0x0, + 0x1f, 0xff, 0xc0, 0x0, 0x7, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x1f, 0xff, 0xc0, 0x0, 0x6f, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xc0, 0x6, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xc0, 0x6f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xc5, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xf8, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0x40, 0xaf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xf3, 0x0, 0x1e, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xc0, 0x0, + 0x6, 0xff, 0xff, 0x30, 0x0, 0x0, 0x1f, 0xff, + 0xc0, 0x0, 0x0, 0xbf, 0xff, 0xd0, 0x0, 0x0, + 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x2f, 0xff, 0xf8, + 0x0, 0x0, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0x30, 0x0, 0x1f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xd0, 0x0, 0x1f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf8, 0x0, + 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0x20, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xc0, 0x1f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf7, + + /* U+006C "l" */ + 0x1f, 0xff, 0xc1, 0xff, 0xfc, 0x1f, 0xff, 0xc1, + 0xff, 0xfc, 0x1f, 0xff, 0xc1, 0xff, 0xfc, 0x1f, + 0xff, 0xc1, 0xff, 0xfc, 0x1f, 0xff, 0xc1, 0xff, + 0xfc, 0x1f, 0xff, 0xc1, 0xff, 0xfc, 0x1f, 0xff, + 0xc1, 0xff, 0xfc, 0x1f, 0xff, 0xc1, 0xff, 0xfc, + 0x1f, 0xff, 0xc1, 0xff, 0xfc, 0x1f, 0xff, 0xc1, + 0xff, 0xfc, 0x1f, 0xff, 0xc1, 0xff, 0xfc, 0x1f, + 0xff, 0xc1, 0xff, 0xfc, 0x1f, 0xff, 0xc1, 0xff, + 0xfc, 0x1f, 0xff, 0xc1, 0xff, 0xfc, 0x1f, 0xff, + 0xc1, 0xff, 0xfc, 0x1f, 0xff, 0xc0, + + /* U+006D "m" */ + 0x0, 0x0, 0x0, 0x0, 0x4, 0x67, 0x53, 0x0, + 0x0, 0x0, 0x0, 0x25, 0x77, 0x51, 0x0, 0x0, + 0x2f, 0xff, 0x50, 0x1a, 0xff, 0xff, 0xff, 0xd5, + 0x0, 0x0, 0x4c, 0xff, 0xff, 0xff, 0xa1, 0x0, + 0x2f, 0xff, 0x54, 0xef, 0xff, 0xff, 0xff, 0xff, + 0x70, 0x8, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x20, + 0x2f, 0xff, 0x8f, 0xff, 0xfe, 0xde, 0xff, 0xff, + 0xf3, 0x8f, 0xff, 0xfd, 0xdf, 0xff, 0xff, 0xc0, + 0x2f, 0xff, 0xff, 0xf9, 0x20, 0x0, 0x5f, 0xff, + 0xfd, 0xff, 0xd4, 0x0, 0x1, 0x9f, 0xff, 0xf3, + 0x2f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xfc, 0x10, 0x0, 0x0, 0xc, 0xff, 0xf7, + 0x2f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfa, + 0x2f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfc, + 0x2f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfc, + 0x2f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfc, + 0x2f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfc, + 0x2f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfc, + 0x2f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfc, + 0x2f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfc, + 0x2f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfc, + 0x2f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfc, + 0x2f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfc, + 0x2f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfc, + 0x2f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfc, + 0x2f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfc, + 0x2f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfc, + 0x2f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfc, + 0x2f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfc, + 0x2f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfc, + + /* U+006E "n" */ + 0x0, 0x0, 0x0, 0x0, 0x3, 0x57, 0x75, 0x10, + 0x0, 0x0, 0xf, 0xff, 0x70, 0x8, 0xef, 0xff, + 0xff, 0xfb, 0x30, 0x0, 0xf, 0xff, 0x72, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0xf, 0xff, + 0x8d, 0xff, 0xff, 0xdd, 0xff, 0xff, 0xff, 0x40, + 0xf, 0xff, 0xff, 0xfc, 0x40, 0x0, 0x6, 0xff, + 0xff, 0xc0, 0xf, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf1, 0xf, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf4, 0xf, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf6, + 0xf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf7, 0xf, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf8, 0xf, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, 0xf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, + 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf8, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf8, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, 0xf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, + 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf8, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf8, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, 0xf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, + 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf8, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf8, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, 0xf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, + + /* U+006F "o" */ + 0x0, 0x0, 0x0, 0x0, 0x25, 0x67, 0x64, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7d, 0xff, + 0xff, 0xff, 0xfb, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xfe, 0xbb, 0xcf, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x3f, 0xff, 0xfd, + 0x40, 0x0, 0x1, 0x9f, 0xff, 0xf9, 0x0, 0x0, + 0xef, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0x40, 0x6, 0xff, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xc0, 0xc, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, + 0xf, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf7, 0x3f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xfb, 0x5f, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xfc, 0x6f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xfd, 0x7f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfe, 0x6f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xfd, 0x5f, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xfc, 0x3f, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfa, + 0xf, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf6, 0xb, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf2, 0x5, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xc0, 0x0, 0xdf, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0x50, 0x0, 0x3f, 0xff, 0xfd, + 0x40, 0x0, 0x1, 0x8f, 0xff, 0xfa, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xfe, 0xba, 0xcf, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x4e, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7e, 0xff, 0xff, 0xff, 0xfb, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x25, 0x77, 0x64, 0x0, + 0x0, 0x0, 0x0, + + /* U+0070 "p" */ + 0x0, 0x0, 0x0, 0x0, 0x15, 0x67, 0x53, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xf8, 0x1, 0xaf, 0xff, + 0xff, 0xfe, 0x70, 0x0, 0x0, 0xf, 0xff, 0x84, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xc1, 0x0, 0x0, + 0xff, 0xfa, 0xff, 0xff, 0xa8, 0x9c, 0xff, 0xff, + 0xd1, 0x0, 0xf, 0xff, 0xff, 0xfb, 0x10, 0x0, + 0x4, 0xef, 0xff, 0xa0, 0x0, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x40, 0xf, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xfb, 0x0, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf1, 0xf, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x50, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xf9, 0xf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xb0, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xfc, 0xf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xc0, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xfb, 0xf, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xa0, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf7, + 0xf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x30, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xe0, 0xf, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf8, 0x0, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0x20, 0xf, 0xff, 0xff, 0xf9, 0x10, 0x0, + 0x8, 0xff, 0xff, 0x60, 0x0, 0xff, 0xff, 0xff, + 0xff, 0xca, 0xbf, 0xff, 0xff, 0x90, 0x0, 0xf, + 0xff, 0xd5, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0xff, 0xfd, 0x2, 0xcf, 0xff, 0xff, + 0xfc, 0x30, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x25, 0x76, 0x51, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+0071 "q" */ + 0x0, 0x0, 0x0, 0x1, 0x56, 0x75, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3b, 0xff, 0xff, + 0xff, 0xd5, 0x1, 0xff, 0xf6, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0x1f, 0xff, 0x60, + 0x0, 0x7f, 0xff, 0xfe, 0xa8, 0x9d, 0xff, 0xf8, + 0xff, 0xf6, 0x0, 0x4f, 0xff, 0xf8, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0x60, 0xd, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf6, 0x4, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x60, 0xbf, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf6, 0xe, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x62, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xf6, 0x3f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0x64, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf6, 0x5f, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0x64, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xf6, 0x3f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x60, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf6, + 0xd, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0x60, 0x8f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf6, 0x1, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x60, + 0x9, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xf6, 0x0, 0x1e, 0xff, 0xfc, 0x30, 0x0, + 0x6, 0xff, 0xff, 0xff, 0x60, 0x0, 0x3f, 0xff, + 0xff, 0xda, 0xbe, 0xff, 0xfe, 0xff, 0xf6, 0x0, + 0x0, 0x3e, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x7f, + 0xff, 0x60, 0x0, 0x0, 0x9, 0xef, 0xff, 0xff, + 0xd5, 0x7, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x46, 0x76, 0x30, 0x0, 0x7f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x60, + + /* U+0072 "r" */ + 0x0, 0x0, 0x0, 0x1, 0x57, 0x51, 0x0, 0x2f, + 0xff, 0x50, 0x6f, 0xff, 0xff, 0xa1, 0x2f, 0xff, + 0x56, 0xff, 0xff, 0xff, 0xe0, 0x2f, 0xff, 0x7f, + 0xff, 0xff, 0xff, 0x90, 0x2f, 0xff, 0xff, 0xfc, + 0x88, 0xaf, 0x30, 0x2f, 0xff, 0xff, 0x70, 0x0, + 0x1, 0x0, 0x2f, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + + /* U+0073 "s" */ + 0x0, 0x0, 0x0, 0x25, 0x77, 0x65, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6d, 0xff, 0xff, 0xff, + 0xfe, 0x81, 0x0, 0x0, 0x0, 0x1c, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x40, 0x0, 0x0, 0xcf, + 0xff, 0xfe, 0xba, 0xbd, 0xff, 0xff, 0xf3, 0x0, + 0x6, 0xff, 0xfc, 0x30, 0x0, 0x0, 0x4d, 0xff, + 0xfb, 0x0, 0xc, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x10, 0xf, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0x40, 0xf, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x24, 0x20, 0x0, + 0xc, 0xff, 0xfb, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xfc, 0x72, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xff, 0xe9, 0x50, 0x0, 0x0, 0x0, 0x0, 0x1d, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xa4, 0x0, 0x0, + 0x0, 0x0, 0x7e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xc2, 0x0, 0x0, 0x0, 0x0, 0x38, 0xdf, 0xff, + 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x5a, 0xef, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xdf, 0xff, 0xf1, + 0x0, 0x25, 0x10, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xf3, 0x7f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf4, 0x4f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf2, 0xe, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xd0, + 0x7, 0xff, 0xff, 0x81, 0x0, 0x0, 0x6, 0xff, + 0xff, 0x60, 0x0, 0xbf, 0xff, 0xff, 0xca, 0xab, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x4b, 0xff, 0xff, 0xff, 0xff, 0xb4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x14, 0x67, 0x76, 0x41, 0x0, + 0x0, 0x0, + + /* U+0074 "t" */ + 0x0, 0x0, 0x0, 0x54, 0x0, 0x0, 0x0, 0x0, + 0x2b, 0xf6, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf6, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x4f, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x4f, 0xff, 0xff, 0xff, + 0xff, 0xf4, 0x0, 0x7, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xfe, 0x41, 0x10, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xf9, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x26, 0x77, 0x63, + + /* U+0075 "u" */ + 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xf6, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf6, 0x1f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf6, 0x1f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf6, + 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xf6, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf6, 0x1f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf6, 0x1f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf6, + 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xf6, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf6, 0x1f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf6, 0x1f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf6, + 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xf6, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xf6, 0x1f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf6, 0xf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf6, + 0xf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xf6, 0xd, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xf6, 0xa, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xf6, 0x5, 0xff, + 0xff, 0xb3, 0x0, 0x1, 0x8f, 0xff, 0xff, 0xf6, + 0x0, 0xcf, 0xff, 0xff, 0xed, 0xef, 0xff, 0xf4, + 0xff, 0xf6, 0x0, 0x1d, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x41, 0xff, 0xf6, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xa1, 0x1, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x46, 0x76, 0x40, 0x0, 0x0, 0x0, 0x0, + + /* U+0076 "v" */ + 0x4f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf4, 0xd, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xe0, 0x7, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x80, 0x2, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x20, 0x0, 0xbf, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xfc, 0x0, 0x0, + 0x5f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf6, 0x0, 0x0, 0xf, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf1, 0x0, 0x0, 0x9, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xa0, 0x0, + 0x0, 0x3, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x0, + 0x0, 0x0, 0xef, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x60, 0x0, 0x4, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xb0, 0x0, 0xa, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf1, 0x0, 0xf, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf7, 0x0, 0x5f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfc, 0x0, + 0xbf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0x11, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x66, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xbb, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, + + /* U+0077 "w" */ + 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf5, + 0x5f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf1, + 0xf, 0xff, 0xe0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xb0, + 0xb, 0xff, 0xf2, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x60, + 0x6, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x10, + 0x1, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x7f, 0xfe, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0xdf, 0xfc, 0x0, + 0x0, 0xcf, 0xff, 0x0, 0x0, 0x0, 0xbf, 0xf8, + 0xef, 0xfa, 0x0, 0x0, 0x2, 0xff, 0xf8, 0x0, + 0x0, 0x8f, 0xff, 0x40, 0x0, 0x0, 0xff, 0xf4, + 0xaf, 0xfe, 0x0, 0x0, 0x7, 0xff, 0xf3, 0x0, + 0x0, 0x3f, 0xff, 0x80, 0x0, 0x4, 0xff, 0xf0, + 0x6f, 0xff, 0x20, 0x0, 0xb, 0xff, 0xe0, 0x0, + 0x0, 0xe, 0xff, 0xc0, 0x0, 0x8, 0xff, 0xc0, + 0x3f, 0xff, 0x60, 0x0, 0xf, 0xff, 0x90, 0x0, + 0x0, 0x9, 0xff, 0xf1, 0x0, 0xd, 0xff, 0x80, + 0xe, 0xff, 0xa0, 0x0, 0x5f, 0xff, 0x40, 0x0, + 0x0, 0x4, 0xff, 0xf5, 0x0, 0x1f, 0xff, 0x30, + 0xa, 0xff, 0xe0, 0x0, 0xaf, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xfa, 0x0, 0x5f, 0xff, 0x0, + 0x6, 0xff, 0xf3, 0x0, 0xef, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xfe, 0x0, 0xaf, 0xfb, 0x0, + 0x2, 0xff, 0xf7, 0x3, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x20, 0xef, 0xf7, 0x0, + 0x0, 0xdf, 0xfb, 0x8, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x72, 0xff, 0xf3, 0x0, + 0x0, 0x9f, 0xff, 0xc, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xb6, 0xff, 0xe0, 0x0, + 0x0, 0x5f, 0xff, 0x5f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xfa, 0xff, 0xa0, 0x0, + 0x0, 0x1f, 0xff, 0xdf, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x80, 0x0, 0x0, 0x0, + + /* U+0078 "x" */ + 0xb, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xb0, 0x1, 0xef, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xfe, 0x10, 0x0, 0x4f, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf4, + 0x0, 0x0, 0x9, 0xff, 0xff, 0x10, 0x0, 0x1, + 0xef, 0xff, 0x80, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xb0, 0x0, 0xb, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xf5, 0x0, 0x6f, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xfe, 0x12, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x9c, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x9a, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xfe, 0x1, 0xef, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xf4, 0x0, 0x5f, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xa0, + 0x0, 0xa, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xfe, 0x10, 0x0, 0x1, 0xef, 0xff, 0x80, + 0x0, 0x0, 0x3f, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xf3, 0x0, 0x0, 0xdf, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xfd, 0x0, 0xa, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xa0, 0x5f, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xf5, + + /* U+0079 "y" */ + 0x1f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xf6, 0xb, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf1, 0x5, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xa0, 0x0, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0x50, 0x0, 0x9f, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfe, 0x0, 0x0, + 0x3f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf9, 0x0, 0x0, 0xd, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf3, 0x0, 0x0, 0x8, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0xe, 0xff, 0xd0, 0x0, + 0x0, 0x2, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0x70, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x30, + 0x0, 0x0, 0xaf, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x90, 0x0, 0x1, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xe0, 0x0, 0x6, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf4, 0x0, 0xc, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xfa, 0x0, 0x1f, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x0, + 0x7f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0x50, 0xcf, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xa1, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xe5, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xfd, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x44, 0x34, 0x9f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0x67, 0x51, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+007A "z" */ + 0x4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x60, 0x4, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x4, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2e, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2e, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfe, 0x33, 0x34, 0x44, 0x44, + 0x44, 0x44, 0x44, 0x40, 0x2f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0x2f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf1, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf1, + + /* U+007B "{" */ + 0x0, 0x0, 0x0, 0x0, 0x15, 0x77, 0x50, 0x0, + 0x0, 0x1, 0xbf, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xd9, 0x0, 0x0, 0xd, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x1c, 0xff, + 0xf1, 0x0, 0x0, 0x6, 0xaf, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xd3, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xfc, 0x10, 0x0, 0x0, 0x0, 0x28, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xfd, 0x90, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x1c, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x2, 0x57, + 0x75, + + /* U+007C "|" */ + 0x78, 0x83, 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, + 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, + 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, + 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, + 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, + 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, + 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, + 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, + 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, + 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, + 0xff, 0xf6, + + /* U+007D "}" */ + 0x77, 0x75, 0x10, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0xd, 0xdf, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xfe, 0x93, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x1a, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x3e, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x2e, 0xff, 0xe6, 0x10, 0x0, 0x0, 0xa, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0x10, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x80, 0x0, 0x0, 0xdd, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x7, 0x76, 0x40, 0x0, 0x0, 0x0, + 0x0, + + /* U+007E "~" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4a, 0xdf, 0xfc, + 0x94, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0x1, + 0xbf, 0xff, 0xff, 0xff, 0xfe, 0x81, 0x0, 0x0, + 0x0, 0x2c, 0xd0, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x51, 0x2, 0x8f, 0xfd, 0x2f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd2, 0xff, 0xd6, 0x20, 0x26, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x2f, 0x90, 0x0, + 0x0, 0x0, 0x28, 0xef, 0xff, 0xff, 0xff, 0xf8, + 0x1, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5a, + 0xdf, 0xfd, 0x82, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00A0 " " */ + + /* U+00A3 "£" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x36, 0x77, 0x63, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x9f, 0xff, 0xff, 0xff, 0xe8, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe4, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xfc, 0xaa, 0xdf, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xfb, 0x20, 0x0, 0x3, + 0xdf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xfa, 0x0, + 0x0, 0x4, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x10, 0x0, 0x9, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x40, + 0x0, 0xa, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7e, 0xca, 0x30, 0x0, 0xb, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x22, 0xcf, 0xff, 0x82, 0x22, 0x22, 0x20, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x60, + 0x11, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1a, 0xff, 0xff, 0xef, 0xff, 0xff, 0xda, 0x85, + 0x32, 0x35, 0x8d, 0x40, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, + 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf0, 0x4, 0xff, 0xa5, 0x21, + 0x0, 0x25, 0x8c, 0xff, 0xff, 0xff, 0xff, 0xb2, + 0x0, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0x57, 0x76, 0x30, 0x0, + + /* U+00A4 "¤" */ + 0x0, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0x0, 0x0, 0xbe, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0x30, 0xb, 0xff, + 0xe2, 0x3, 0x9d, 0xff, 0xeb, 0x60, 0xa, 0xff, + 0xf3, 0x1d, 0xff, 0xfe, 0xbf, 0xff, 0xff, 0xff, + 0xfe, 0xbf, 0xff, 0xf6, 0x1, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x1c, 0xff, 0xff, 0xfc, 0x88, 0xae, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0xa, 0xff, 0xfd, 0x20, 0x0, + 0x0, 0x9f, 0xff, 0xf1, 0x0, 0x0, 0x2f, 0xff, + 0xd1, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf9, 0x0, + 0x0, 0x7f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x0, 0x0, 0xbf, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0x20, 0x0, 0xdf, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x40, 0x0, 0xdf, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x40, 0x0, 0xbf, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x20, 0x0, + 0x7f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x0, 0x0, 0x2f, 0xff, 0xd1, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xf9, 0x0, 0x0, 0xa, 0xff, + 0xfd, 0x30, 0x0, 0x0, 0x9f, 0xff, 0xf1, 0x0, + 0x0, 0x1c, 0xff, 0xff, 0xfc, 0x88, 0xae, 0xff, + 0xff, 0xf5, 0x0, 0x1, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x1d, 0xff, + 0xfe, 0xaf, 0xff, 0xff, 0xff, 0xfe, 0xbf, 0xff, + 0xf6, 0xb, 0xff, 0xe2, 0x3, 0x9d, 0xff, 0xeb, + 0x60, 0x9, 0xff, 0xf3, 0x0, 0xbe, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0x30, 0x0, + 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x0, + + /* U+00A5 "¥" */ + 0xbf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x22, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0x80, 0x8, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xe0, 0x0, 0xe, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x5f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x3, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xf2, 0x0, 0x0, 0xd, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xb0, 0x0, 0x6, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x50, 0x0, 0xef, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xfd, 0x0, + 0x7f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf6, 0x1f, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xe8, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x0, 0x1, 0x22, 0x22, 0x22, 0x22, 0xbf, 0xff, + 0x52, 0x22, 0x22, 0x22, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+00A6 "¦" */ + 0xbb, 0xb4, 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, + 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, + 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, + 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbc, 0xc4, 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, + 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, + 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, + 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, 0xff, 0xf6, + 0xff, 0xf6, + + /* U+00A7 "§" */ + 0x0, 0x0, 0x0, 0x0, 0x36, 0x77, 0x63, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7e, 0xff, + 0xff, 0xff, 0xe8, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x1c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe3, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfd, 0xaa, 0xdf, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x6, 0xff, 0xfe, + 0x40, 0x0, 0x4, 0xef, 0xff, 0xa0, 0x0, 0x0, + 0xd, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xf2, 0x0, 0x0, 0xf, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, 0x1f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf9, 0x0, + 0x0, 0xe, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x1, + 0x31, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfc, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xd2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xfc, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xef, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xa2, 0xbf, 0xff, + 0xff, 0xe4, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, + 0x0, 0x5, 0xef, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0xc, 0xff, 0xc0, 0x0, 0x0, 0x1a, 0xff, 0xff, + 0xfe, 0x30, 0x0, 0x1f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x4d, 0xff, 0xff, 0xf4, 0x0, 0x2f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0x30, 0x1f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xd0, 0xe, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf3, 0x8, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xf7, 0x0, 0xdf, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf8, 0x0, 0x2e, 0xff, + 0xff, 0xd4, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf6, + 0x0, 0x2, 0xdf, 0xff, 0xff, 0xb2, 0x0, 0x0, + 0x8, 0xff, 0xf3, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x4f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x4e, 0xff, 0xff, 0xfd, 0x37, 0xff, 0xfd, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xcf, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2d, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xfb, 0x0, 0x0, 0x36, 0x8a, 0x10, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0x0, 0x0, 0xbf, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x0, 0x0, 0x7f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x0, 0x0, 0x1f, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xfb, 0x0, 0x0, + 0xa, 0xff, 0xff, 0x81, 0x0, 0x0, 0x8f, 0xff, + 0xf4, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xff, 0xcb, + 0xcf, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x1c, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6d, 0xff, 0xff, 0xff, 0xfc, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x25, + 0x77, 0x65, 0x10, 0x0, 0x0, 0x0, + + /* U+00A8 "¨" */ + 0x35, 0x55, 0x10, 0x0, 0x35, 0x55, 0x1b, 0xff, + 0xf5, 0x0, 0xa, 0xff, 0xf5, 0xbf, 0xff, 0x50, + 0x0, 0xaf, 0xff, 0x5b, 0xff, 0xf5, 0x0, 0xa, + 0xff, 0xf5, 0xbf, 0xff, 0x50, 0x0, 0xaf, 0xff, + 0x50, + + /* U+00A9 "©" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x8b, 0xef, + 0xff, 0xda, 0x72, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x8e, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xfe, + 0xcb, 0xab, 0xdf, 0xff, 0xff, 0xc2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1c, 0xff, 0xfe, 0x73, + 0x0, 0x0, 0x0, 0x15, 0xbf, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, 0xe7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3c, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xd2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0xc, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf3, 0x0, 0x0, 0x7, 0xff, 0xd0, 0x0, + 0x0, 0x3, 0x9d, 0xef, 0xec, 0x71, 0x0, 0x0, + 0x5, 0xff, 0xe0, 0x0, 0x1, 0xff, 0xe1, 0x0, + 0x0, 0x1b, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0xa, 0xff, 0x80, 0x0, 0x9f, 0xf7, 0x0, + 0x0, 0x1e, 0xff, 0xfa, 0x76, 0x8d, 0xff, 0xf6, + 0x0, 0x0, 0x1e, 0xff, 0x10, 0xf, 0xfd, 0x0, + 0x0, 0xc, 0xff, 0xc2, 0x0, 0x0, 0x5, 0xff, + 0xf2, 0x0, 0x0, 0x7f, 0xf7, 0x5, 0xff, 0x70, + 0x0, 0x5, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x6, + 0xff, 0x80, 0x0, 0x1, 0xff, 0xc0, 0x9f, 0xf3, + 0x0, 0x0, 0xbf, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x7, 0x40, 0x0, 0x0, 0xc, 0xff, 0xc, 0xfe, + 0x0, 0x0, 0xf, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xf3, 0xef, + 0xd0, 0x0, 0x2, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0x5f, + 0xfb, 0x0, 0x0, 0x3f, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xf6, + 0xff, 0xb0, 0x0, 0x3, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0x6e, 0xfd, 0x0, 0x0, 0x2f, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xf5, 0xcf, 0xe0, 0x0, 0x0, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0x30, 0x0, 0x0, 0x8, + 0xff, 0x3a, 0xff, 0x30, 0x0, 0xb, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xd0, 0x0, 0x0, + 0xcf, 0xf0, 0x6f, 0xf7, 0x0, 0x0, 0x4f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfa, 0x0, 0x0, + 0x1f, 0xfc, 0x1, 0xff, 0xd0, 0x0, 0x0, 0xbf, + 0xfc, 0x20, 0x0, 0x1, 0x9f, 0xff, 0x20, 0x0, + 0x7, 0xff, 0x70, 0xa, 0xff, 0x70, 0x0, 0x1, + 0xdf, 0xff, 0xb8, 0x8a, 0xff, 0xff, 0x50, 0x0, + 0x1, 0xef, 0xf1, 0x0, 0x2f, 0xfe, 0x10, 0x0, + 0x1, 0xcf, 0xff, 0xff, 0xff, 0xfe, 0x40, 0x0, + 0x0, 0x9f, 0xf8, 0x0, 0x0, 0x8f, 0xfd, 0x0, + 0x0, 0x0, 0x49, 0xdf, 0xfe, 0xb6, 0x0, 0x0, + 0x0, 0x6f, 0xfe, 0x0, 0x0, 0x0, 0xcf, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x30, 0x0, 0x0, 0x1, 0xef, + 0xfd, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x2, + 0xef, 0xfe, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xbf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xcf, 0xff, 0xe7, 0x30, 0x0, 0x0, 0x1, + 0x5a, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xec, 0xba, 0xcd, + 0xff, 0xff, 0xfc, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x29, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xc5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x59, 0xce, 0xff, + 0xfd, 0xa7, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00AA "ª" */ + 0x0, 0x0, 0x6c, 0xef, 0xd9, 0x10, 0x6f, 0xfb, + 0x0, 0x1c, 0xff, 0xff, 0xff, 0xe4, 0xaf, 0xf6, + 0x0, 0xcf, 0xff, 0x96, 0x8e, 0xff, 0xef, 0xf2, + 0x6, 0xff, 0xf4, 0x0, 0x1, 0xdf, 0xff, 0xe0, + 0xd, 0xff, 0x90, 0x0, 0x0, 0x4f, 0xff, 0xb0, + 0x1f, 0xff, 0x40, 0x0, 0x0, 0xe, 0xff, 0x70, + 0x3f, 0xff, 0x10, 0x0, 0x0, 0xb, 0xff, 0x40, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0xa, 0xff, 0x10, + 0x4f, 0xff, 0x0, 0x0, 0x0, 0xa, 0xff, 0x10, + 0x3f, 0xff, 0x10, 0x0, 0x0, 0xc, 0xff, 0x40, + 0xf, 0xff, 0x40, 0x0, 0x0, 0xf, 0xff, 0x70, + 0xc, 0xff, 0x90, 0x0, 0x0, 0x6f, 0xff, 0xb0, + 0x5, 0xff, 0xf3, 0x0, 0x2, 0xef, 0xff, 0xf0, + 0x0, 0xcf, 0xff, 0x96, 0x8f, 0xfe, 0xef, 0xf4, + 0x0, 0x1c, 0xff, 0xff, 0xff, 0xf4, 0x8f, 0xf9, + 0x0, 0x0, 0x6c, 0xff, 0xd9, 0x20, 0x15, 0x54, + + /* U+00AB "«" */ + 0x0, 0x0, 0x0, 0x1, 0x55, 0x40, 0x0, 0x0, + 0x45, 0x51, 0x0, 0x0, 0x0, 0xc, 0xff, 0x80, + 0x0, 0x7, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x7f, + 0xfe, 0x0, 0x0, 0x2f, 0xff, 0x40, 0x0, 0x0, + 0x3, 0xff, 0xf5, 0x0, 0x0, 0xdf, 0xfb, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xc0, 0x0, 0x8, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x30, 0x0, + 0x3f, 0xff, 0x80, 0x0, 0x0, 0x4, 0xff, 0xf9, + 0x0, 0x0, 0xef, 0xfe, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xf1, 0x0, 0xa, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x70, 0x0, 0x5f, 0xff, 0xc0, + 0x0, 0x0, 0x6, 0xff, 0xfd, 0x0, 0x1, 0xef, + 0xff, 0x30, 0x0, 0x0, 0xd, 0xff, 0xf8, 0x0, + 0x6, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0x10, 0x0, 0xcf, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xa0, 0x0, 0x2f, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf3, 0x0, 0x6, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfc, + 0x0, 0x0, 0xbf, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x50, 0x0, 0x1e, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xe0, 0x0, 0x5, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x1, 0xef, 0xf8, 0x0, + 0x0, 0xaf, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x10, 0x0, 0xe, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xa0, 0x0, 0x3, 0xff, 0xf1, + + /* U+00AC "¬" */ + 0x48, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, + 0x88, 0x88, 0x82, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x8f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf4, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0x88, 0x82, + + /* U+00AD "­" */ + 0x8d, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0x39, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf4, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x49, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf4, + + /* U+00AE "®" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x8b, 0xef, + 0xff, 0xda, 0x72, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x8e, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xfe, + 0xcb, 0xab, 0xdf, 0xff, 0xff, 0xc2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1c, 0xff, 0xfe, 0x73, + 0x0, 0x0, 0x0, 0x15, 0xbf, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, 0xe7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3c, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xd2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0xc, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf3, 0x0, 0x0, 0x7, 0xff, 0xd0, 0x0, + 0x45, 0x55, 0x55, 0x54, 0x31, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xe0, 0x0, 0x1, 0xff, 0xe1, 0x0, + 0xe, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x50, 0x0, + 0x0, 0xa, 0xff, 0x80, 0x0, 0x9f, 0xf7, 0x0, + 0x0, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x1e, 0xff, 0x10, 0xf, 0xfd, 0x0, + 0x0, 0xe, 0xfe, 0x0, 0x0, 0x13, 0x9f, 0xff, + 0x20, 0x0, 0x0, 0x7f, 0xf7, 0x5, 0xff, 0x70, + 0x0, 0x0, 0xef, 0xe0, 0x0, 0x0, 0x0, 0xaf, + 0xf7, 0x0, 0x0, 0x1, 0xff, 0xc0, 0x9f, 0xf3, + 0x0, 0x0, 0xe, 0xfe, 0x0, 0x0, 0x0, 0x7, + 0xff, 0x80, 0x0, 0x0, 0xc, 0xff, 0xc, 0xfe, + 0x0, 0x0, 0x0, 0xef, 0xe0, 0x0, 0x0, 0x0, + 0xbf, 0xf5, 0x0, 0x0, 0x0, 0x8f, 0xf3, 0xef, + 0xd0, 0x0, 0x0, 0xe, 0xfe, 0x0, 0x0, 0x13, + 0xaf, 0xfe, 0x0, 0x0, 0x0, 0x5, 0xff, 0x5f, + 0xfb, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x30, 0x0, 0x0, 0x0, 0x4f, 0xf6, + 0xff, 0xb0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, + 0xff, 0xd8, 0x10, 0x0, 0x0, 0x0, 0x4, 0xff, + 0x6e, 0xfd, 0x0, 0x0, 0x0, 0xef, 0xf6, 0x68, + 0xdf, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xf5, 0xcf, 0xe0, 0x0, 0x0, 0xe, 0xfe, 0x0, + 0x0, 0x9f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0x3a, 0xff, 0x30, 0x0, 0x0, 0xef, 0xe0, + 0x0, 0x0, 0xcf, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xf0, 0x6f, 0xf7, 0x0, 0x0, 0xe, 0xfe, + 0x0, 0x0, 0x2, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x1f, 0xfc, 0x1, 0xff, 0xd0, 0x0, 0x0, 0xef, + 0xe0, 0x0, 0x0, 0x8, 0xff, 0xb0, 0x0, 0x0, + 0x7, 0xff, 0x70, 0xa, 0xff, 0x70, 0x0, 0xe, + 0xfe, 0x0, 0x0, 0x0, 0xe, 0xff, 0x50, 0x0, + 0x1, 0xef, 0xf1, 0x0, 0x2f, 0xfe, 0x10, 0x0, + 0xef, 0xe0, 0x0, 0x0, 0x0, 0x6f, 0xfe, 0x0, + 0x0, 0x9f, 0xf8, 0x0, 0x0, 0x8f, 0xfd, 0x0, + 0xb, 0xcb, 0x0, 0x0, 0x0, 0x0, 0xbc, 0xc6, + 0x0, 0x6f, 0xfe, 0x0, 0x0, 0x0, 0xcf, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x30, 0x0, 0x0, 0x1, 0xef, + 0xfd, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x2, + 0xef, 0xfe, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xbf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xcf, 0xff, 0xe7, 0x30, 0x0, 0x0, 0x1, + 0x5a, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xec, 0xba, 0xcd, + 0xff, 0xff, 0xfc, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x29, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xc5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x59, 0xce, 0xff, + 0xfd, 0xa7, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00B0 "°" */ + 0x0, 0x1, 0x8d, 0xfe, 0xb5, 0x0, 0x0, 0x2, + 0xef, 0xff, 0xff, 0xfa, 0x0, 0x1, 0xef, 0xf8, + 0x56, 0xbf, 0xf9, 0x0, 0x9f, 0xf3, 0x0, 0x0, + 0x9f, 0xf3, 0xf, 0xf7, 0x0, 0x0, 0x0, 0xef, + 0x91, 0xff, 0x30, 0x0, 0x0, 0xa, 0xfb, 0x1f, + 0xf3, 0x0, 0x0, 0x0, 0xaf, 0xb0, 0xef, 0x80, + 0x0, 0x0, 0xe, 0xf8, 0x9, 0xff, 0x30, 0x0, + 0x9, 0xff, 0x30, 0x1e, 0xff, 0x95, 0x6c, 0xff, + 0x90, 0x0, 0x3e, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x18, 0xdf, 0xeb, 0x50, 0x0, + + /* U+00B1 "±" */ + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x48, 0x88, 0x88, 0x88, 0x8f, 0xff, 0xd8, 0x88, + 0x88, 0x88, 0x82, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x8f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf4, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0x88, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x49, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x92, 0x8f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf4, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + + /* U+00B2 "²" */ + 0x0, 0x1, 0x8c, 0xff, 0xfd, 0x93, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xff, 0xff, 0x80, 0x2, 0xff, + 0xff, 0xa9, 0xaf, 0xff, 0xf5, 0xa, 0xff, 0xd1, + 0x0, 0x1, 0xef, 0xfb, 0xa, 0xce, 0x60, 0x0, + 0x0, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x2, 0xdf, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xfc, 0x20, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xfe, 0x99, 0x99, + 0x99, 0x98, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + + /* U+00B3 "³" */ + 0x0, 0x3, 0x9d, 0xff, 0xec, 0x81, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0x40, 0x3, 0xff, + 0xfc, 0x76, 0x9f, 0xff, 0xd0, 0xb, 0xff, 0xa0, + 0x0, 0x6, 0xff, 0xf1, 0x0, 0x13, 0x10, 0x0, + 0x5, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x1, 0x5e, + 0xff, 0x80, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xd6, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xe8, 0x0, + 0x0, 0x0, 0x0, 0x56, 0x8d, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xfc, 0x2a, 0xcd, 0x10, + 0x0, 0x0, 0xaf, 0xfd, 0xe, 0xff, 0xa0, 0x0, + 0x5, 0xff, 0xf9, 0x7, 0xff, 0xfd, 0x99, 0xcf, + 0xff, 0xf2, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xfe, + 0x30, 0x0, 0x3, 0x9d, 0xff, 0xec, 0x71, 0x0, + + /* U+00B5 "µ" */ + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0x7f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf7, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x7f, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf7, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x7f, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xf7, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x7f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf7, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x7f, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf7, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x7f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf7, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0x7f, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf7, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x7f, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf7, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0x7f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xf7, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xfb, + 0x30, 0x2, 0x8f, 0xff, 0xff, 0xf7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0xff, 0x7f, + 0xff, 0xd7, 0xff, 0xff, 0xff, 0xff, 0xe2, 0xff, + 0xf7, 0xff, 0xfd, 0x5, 0xef, 0xff, 0xff, 0xb1, + 0xf, 0xff, 0x7f, 0xff, 0xd0, 0x0, 0x46, 0x75, + 0x10, 0x0, 0x0, 0x0, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00B6 "¶" */ + 0x0, 0x0, 0x0, 0x49, 0xce, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x4, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x5, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xba, 0xaa, 0xaf, 0xff, + 0xda, 0xa7, 0x1, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xf2, 0x0, 0x1, 0xff, 0xf9, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x20, 0x0, 0x1f, + 0xff, 0x90, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf2, 0x0, 0x1, 0xff, 0xf9, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x1f, 0xff, 0x90, 0x0, 0xf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf2, 0x0, 0x1, 0xff, 0xf9, 0x0, + 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x1f, 0xff, 0x90, 0x0, 0xf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x1, 0xff, 0xf9, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x1f, 0xff, 0x90, 0x0, 0x7, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x1, 0xff, + 0xf9, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x1f, 0xff, 0x90, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x1, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x1f, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x2b, 0xff, 0xff, 0xff, 0xf2, 0x0, + 0x1, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x57, 0xbf, 0xff, 0x20, 0x0, 0x1f, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf2, + 0x0, 0x1, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x20, 0x0, 0x1f, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xf2, 0x0, 0x1, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x20, 0x0, 0x1f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf2, 0x0, 0x1, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x20, 0x0, + 0x1f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xf2, 0x0, 0x1, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x20, + 0x0, 0x1f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xf2, 0x0, 0x1, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x20, 0x0, 0x1f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xf2, 0x0, 0x1, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x20, 0x0, 0x1f, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf2, 0x0, 0x1, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x20, 0x0, 0x1f, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf2, 0x0, + 0x1, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0x20, 0x0, 0x1f, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf2, + 0x0, 0x1, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x20, 0x0, 0x1f, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xf2, 0x0, 0x1, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x20, 0x0, 0x1f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf2, 0x0, 0x1, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x20, 0x0, + 0x1f, 0xff, 0x90, 0x0, + + /* U+00B7 "·" */ + 0x5, 0x55, 0x51, 0xf, 0xff, 0xf5, 0xf, 0xff, + 0xf5, 0xf, 0xff, 0xf5, 0xf, 0xff, 0xf5, + + /* U+00BB "»" */ + 0x45, 0x52, 0x0, 0x0, 0x25, 0x53, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xd0, 0x0, 0x1, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0xd, 0xff, 0x90, 0x0, 0x7, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x40, + 0x0, 0xd, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xaf, + 0xfe, 0x10, 0x0, 0x5f, 0xff, 0x50, 0x0, 0x0, + 0x1, 0xff, 0xfb, 0x0, 0x0, 0xbf, 0xff, 0x10, + 0x0, 0x0, 0x7, 0xff, 0xf6, 0x0, 0x2, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf2, 0x0, + 0x9, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xc0, 0x0, 0x1e, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x70, 0x0, 0x6f, 0xff, 0xd0, 0x0, + 0x0, 0x6, 0xff, 0xfe, 0x0, 0x1, 0xff, 0xff, + 0x40, 0x0, 0x0, 0xef, 0xff, 0x40, 0x0, 0x9f, + 0xff, 0xa0, 0x0, 0x0, 0x8f, 0xff, 0x90, 0x0, + 0x2f, 0xff, 0xe1, 0x0, 0x0, 0x1f, 0xff, 0xd0, + 0x0, 0xb, 0xff, 0xf4, 0x0, 0x0, 0xa, 0xff, + 0xf3, 0x0, 0x5, 0xff, 0xf8, 0x0, 0x0, 0x4, + 0xff, 0xf7, 0x0, 0x0, 0xdf, 0xfd, 0x0, 0x0, + 0x0, 0xdf, 0xfc, 0x0, 0x0, 0x7f, 0xff, 0x20, + 0x0, 0x0, 0x7f, 0xff, 0x20, 0x0, 0x1f, 0xff, + 0x60, 0x0, 0x0, 0x1f, 0xff, 0x60, 0x0, 0xa, + 0xff, 0xb0, 0x0, 0x0, 0x9, 0xff, 0xb0, 0x0, + 0x3, 0xff, 0xe1, 0x0, 0x0, 0x0, + + /* U+00BD "½" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x1b, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x20, 0x0, 0x0, 0x17, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xf5, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xbe, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0x90, 0x0, 0x0, 0x0, 0xbf, 0xd5, + 0xe, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x64, + 0x0, 0xe, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x9, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0x30, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0x30, 0x0, 0x0, 0x1, 0xef, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0x30, 0x0, 0x0, 0xb, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfd, 0x0, 0x0, 0x1, 0x8c, 0xef, 0xfd, + 0x93, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf3, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0x70, 0x0, 0x2, 0xff, 0xfe, + 0xa8, 0xaf, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xfb, 0x0, 0x0, 0xa, 0xff, + 0xd1, 0x0, 0x1, 0xef, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xe1, 0x0, 0x0, 0x9, + 0xcd, 0x60, 0x0, 0x0, 0x9f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xdf, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xfe, 0x99, 0x99, 0x99, 0x98, 0x0, + 0x0, 0xaf, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x0, 0x5, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x0, 0x7, 0x88, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0384 "΄" */ + 0x0, 0x9, 0xff, 0xfe, 0x40, 0x1, 0xff, 0xff, + 0x80, 0x0, 0x8f, 0xff, 0xb0, 0x0, 0x1f, 0xff, + 0xe1, 0x0, 0x8, 0xff, 0xf3, 0x0, 0x0, 0xef, + 0xf5, 0x0, 0x0, + + /* U+0386 "Ά" */ + 0x0, 0x0, 0x3f, 0xff, 0xfb, 0x0, 0x1f, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xfd, 0x0, 0x8, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0x20, 0x0, 0xef, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x40, 0x0, 0x4f, 0xff, 0xdf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0x70, 0x0, 0xa, 0xff, 0xe6, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xee, + 0xa0, 0x0, 0x1, 0xff, 0xfa, 0x1f, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x60, 0xbf, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf1, 0x5, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xfb, 0x0, 0xe, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x50, 0x0, 0x9f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf0, 0x0, 0x2, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xf9, 0x0, 0x0, 0xc, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x30, 0x0, 0x0, 0x6f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xfd, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x5e, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x7, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xf2, 0x0, 0x0, 0x4f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0x90, 0x0, 0xa, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0x0, 0x1, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xf6, 0x0, 0x6f, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xd0, 0xd, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x30, + + /* U+0388 "Έ" */ + 0x0, 0x4f, 0xff, 0xf9, 0x0, 0x6f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0xc, 0xff, 0xfc, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x60, 0x4, 0xff, 0xfe, 0x10, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf6, 0x0, 0xbf, 0xff, 0x30, + 0x0, 0x6, 0xff, 0xfe, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0x40, 0x3f, 0xff, + 0x60, 0x0, 0x0, 0x6f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xee, 0x90, 0x0, 0x0, 0x6, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xea, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfe, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xa1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x20, + + /* U+0389 "Ή" */ + 0x0, 0x4f, 0xff, 0xfa, 0x4, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x70, 0xc, 0xff, 0xfc, 0x0, 0x4f, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf7, 0x3, 0xff, 0xfe, 0x10, 0x4, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x70, 0xbf, 0xff, 0x40, + 0x0, 0x4f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, 0x3f, 0xff, + 0x70, 0x0, 0x4, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x79, + 0xee, 0xa0, 0x0, 0x0, 0x4f, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xef, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, + + /* U+038A "Ί" */ + 0x0, 0x4f, 0xff, 0xfa, 0x4, 0xff, 0xfe, 0x0, + 0xcf, 0xff, 0xc0, 0x4, 0xff, 0xfe, 0x3, 0xff, + 0xfe, 0x10, 0x4, 0xff, 0xfe, 0xb, 0xff, 0xf4, + 0x0, 0x4, 0xff, 0xfe, 0x3f, 0xff, 0x70, 0x0, + 0x4, 0xff, 0xfe, 0x9e, 0xea, 0x0, 0x0, 0x4, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xfe, + + /* U+038C "Ό" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x56, 0x77, 0x64, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0x90, 0x0, 0x3, + 0x9e, 0xff, 0xff, 0xff, 0xff, 0xe9, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xc0, 0x0, + 0x2b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xa1, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xe1, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe4, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf3, 0x0, 0x7f, 0xff, 0xff, 0xe9, 0x52, 0x11, + 0x35, 0xaf, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x3, + 0xff, 0xf6, 0x0, 0x6f, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x19, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0xae, 0xe9, 0x0, 0x3f, 0xff, 0xfe, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf1, + 0x0, 0x0, 0x7, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0x60, 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf9, 0x0, 0x0, 0xd, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xc0, 0x0, 0x0, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xfe, 0x0, 0x0, + 0x1f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf0, + 0x0, 0x1, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0x0, 0x0, 0x1f, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xf0, 0x0, 0x0, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xfe, 0x0, 0x0, 0xe, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xc0, 0x0, 0x0, + 0xbf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xfa, 0x0, + 0x0, 0x7, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x2f, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xfe, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfe, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xe8, 0x42, 0x1, 0x24, 0x9e, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1a, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xa1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x8e, 0xff, 0xff, + 0xff, 0xff, 0xe9, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x56, 0x77, 0x64, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+038E "Ύ" */ + 0x0, 0x4f, 0xff, 0xf9, 0x0, 0x7f, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xb0, 0x0, 0xcf, 0xff, 0xc0, + 0x0, 0xc, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfe, 0x10, + 0x4, 0xff, 0xfe, 0x10, 0x0, 0x2, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xf4, 0x0, 0xb, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x90, 0x0, + 0x3f, 0xff, 0x60, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfd, 0x0, 0x0, 0xae, 0xe9, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf8, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0x30, 0x0, 0xc, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xc0, + 0x0, 0x7f, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf6, 0x2, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, + 0x1b, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xcf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+038F "Ώ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x56, 0x77, 0x64, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xf9, 0x0, 0x0, 0x39, + 0xef, 0xff, 0xff, 0xff, 0xfd, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xc0, 0x0, 0x1b, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x60, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xfe, 0x10, 0x4, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf3, 0x0, + 0x5f, 0xff, 0xff, 0xe9, 0x42, 0x1, 0x37, 0xdf, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x3f, 0xff, 0x60, + 0x3, 0xff, 0xff, 0xfa, 0x10, 0x0, 0x0, 0x0, + 0x6, 0xef, 0xff, 0xf8, 0x0, 0x0, 0xae, 0xe9, + 0x0, 0xe, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2e, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0xb, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0x10, 0x0, 0x0, 0xf, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x50, 0x0, 0x0, 0x2f, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0x70, 0x0, 0x0, 0x4f, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x90, 0x0, 0x0, + 0x5f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xa0, 0x0, + 0x0, 0x5f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xa0, + 0x0, 0x0, 0x4f, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xa0, 0x0, 0x0, 0x3f, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0x80, 0x0, 0x0, 0xf, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x50, 0x0, 0x0, 0xc, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0x20, 0x0, 0x0, 0x7, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x2, 0xdf, 0xfe, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xa1, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xe3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7a, 0xaa, + 0xaa, 0xbf, 0xff, 0xff, 0x50, 0x0, 0x1c, 0xff, + 0xff, 0xca, 0xaa, 0xaa, 0xa0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, + + /* U+0390 "ΐ" */ + 0x0, 0x0, 0x0, 0x3, 0xff, 0xfa, 0x0, 0x0, + 0x11, 0x10, 0x0, 0xb, 0xff, 0xd0, 0x11, 0x10, + 0xef, 0xfc, 0x0, 0x2f, 0xff, 0x30, 0xff, 0xfb, + 0xef, 0xfc, 0x0, 0xaf, 0xf7, 0x0, 0xff, 0xfb, + 0xef, 0xfc, 0x2, 0xff, 0xc0, 0x0, 0xff, 0xfb, + 0xef, 0xfc, 0x9, 0xff, 0x10, 0x0, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, + + /* U+0391 "Α" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xdf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xe6, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xfa, 0x1f, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x60, 0xaf, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf1, 0x5, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xfb, 0x0, 0xe, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x50, 0x0, 0x8f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xe0, 0x0, 0x2, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xf9, 0x0, 0x0, 0xc, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x30, 0x0, 0x0, 0x6f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xfd, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x5e, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x7, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xf2, 0x0, 0x0, 0x4f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0x90, 0x0, 0xa, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0x0, 0x1, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xf6, 0x0, 0x6f, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xd0, 0xd, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x30, + + /* U+0392 "Β" */ + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xda, + 0x71, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x10, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x30, 0x0, 0xc, 0xff, 0xfc, + 0xaa, 0xaa, 0xaa, 0xab, 0xdf, 0xff, 0xff, 0xfe, + 0x20, 0x0, 0xcf, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x3, 0x9f, 0xff, 0xfb, 0x0, 0xc, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xf1, 0x0, 0xcf, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x50, 0xc, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf7, 0x0, 0xcf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x70, + 0xc, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf5, 0x0, 0xcf, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0x10, 0xc, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x80, 0x0, 0xcf, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x2, 0x48, 0xef, 0xff, + 0xc0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0xcf, 0xff, 0xca, 0xaa, 0xaa, 0xaa, 0xbb, 0xdf, + 0xff, 0xff, 0xfb, 0x0, 0xc, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xcf, 0xff, 0xf9, + 0x0, 0xcf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xf3, 0xc, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xa0, 0xcf, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xfe, 0xc, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xf0, 0xcf, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xc, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xe0, 0xcf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xfa, + 0xc, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0x50, 0xcf, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4b, 0xff, 0xff, + 0xd0, 0xc, 0xff, 0xfc, 0xaa, 0xaa, 0xaa, 0xaa, + 0xbd, 0xff, 0xff, 0xff, 0xf3, 0x0, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf4, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xa1, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xec, 0x96, + 0x10, 0x0, 0x0, 0x0, + + /* U+0393 "Γ" */ + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x37, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf3, 0x7f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x37, + 0xff, 0xfe, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xa2, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0394 "Δ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xdf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xe6, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xfa, 0x1f, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x60, 0xbf, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf1, 0x6, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xfb, 0x0, 0xf, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x60, 0x0, 0xaf, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xf0, 0x0, 0x3, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xfa, 0x0, 0x0, 0xd, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x40, 0x0, 0x0, 0x7f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xe0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x8, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0xef, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xf2, 0x0, 0x0, 0x4f, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0x90, 0x0, 0xa, 0xff, 0xfe, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaf, 0xff, + 0xff, 0x0, 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd0, 0xd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x30, + + /* U+0395 "Ε" */ + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x8f, 0xff, 0xea, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xa2, + 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x10, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x10, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x10, + 0x8f, 0xff, 0xea, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0x0, 0x8f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xea, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, + + /* U+0396 "Ζ" */ + 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x6f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0x3a, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xfd, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, + 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1d, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xfe, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xa7, 0x3f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfb, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, + + /* U+0397 "Η" */ + 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf3, 0x7f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf3, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, 0x7f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf3, 0x7f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf3, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, 0x7f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf3, 0x7f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, + 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf3, 0x7f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf3, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, 0x7f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf3, 0x7f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf3, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf3, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, + 0x7f, 0xff, 0xea, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaf, 0xff, 0xf3, 0x7f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf3, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, 0x7f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf3, 0x7f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf3, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, 0x7f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf3, 0x7f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, + 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf3, 0x7f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf3, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, 0x7f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf3, 0x7f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf3, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, 0x7f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf3, + + /* U+0398 "Θ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x46, 0x77, + 0x65, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0x8d, 0xff, 0xff, 0xff, + 0xff, 0xea, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x19, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xfa, 0x53, 0x11, 0x24, 0x9e, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0x91, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xef, 0xff, 0xf4, 0x0, 0x0, 0xb, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xe0, 0x0, 0x3, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0x70, 0x0, 0xaf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfe, 0x0, 0xf, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf4, 0x4, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x90, 0x8f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xfc, 0xb, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xf0, 0xdf, 0xff, 0x80, 0x0, 0x1a, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xa3, 0x0, 0x4, 0xff, 0xff, + 0x1e, 0xff, 0xf7, 0x0, 0x1, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x2f, 0xff, 0xf2, + 0xef, 0xff, 0x60, 0x0, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x2, 0xff, 0xff, 0x2e, + 0xff, 0xf6, 0x0, 0x1, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x2f, 0xff, 0xf2, 0xdf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x1b, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf0, 0x8f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xfc, 0x4, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x90, 0xf, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xf4, 0x0, 0x9f, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xfe, 0x0, 0x3, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0x70, 0x0, 0xa, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xff, 0xe0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xdf, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xef, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xe9, + 0x42, 0x10, 0x24, 0x8d, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x18, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x7d, 0xff, 0xff, + 0xff, 0xff, 0xe9, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x46, 0x77, + 0x75, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0399 "Ι" */ + 0xff, 0xff, 0x3f, 0xff, 0xf3, 0xff, 0xff, 0x3f, + 0xff, 0xf3, 0xff, 0xff, 0x3f, 0xff, 0xf3, 0xff, + 0xff, 0x3f, 0xff, 0xf3, 0xff, 0xff, 0x3f, 0xff, + 0xf3, 0xff, 0xff, 0x3f, 0xff, 0xf3, 0xff, 0xff, + 0x3f, 0xff, 0xf3, 0xff, 0xff, 0x3f, 0xff, 0xf3, + 0xff, 0xff, 0x3f, 0xff, 0xf3, 0xff, 0xff, 0x3f, + 0xff, 0xf3, 0xff, 0xff, 0x3f, 0xff, 0xf3, 0xff, + 0xff, 0x3f, 0xff, 0xf3, 0xff, 0xff, 0x3f, 0xff, + 0xf3, 0xff, 0xff, 0x3f, 0xff, 0xf3, 0xff, 0xff, + 0x3f, 0xff, 0xf3, 0xff, 0xff, 0x30, + + /* U+039A "Κ" */ + 0xcf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xf3, 0xc, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xe3, 0x0, 0xcf, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xe2, 0x0, + 0xc, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xe2, 0x0, 0x0, 0xcf, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xd1, 0x0, 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xd1, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x60, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x60, 0x0, 0xa, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf6, 0x0, + 0xa, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x60, 0xa, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf6, 0xa, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x6a, + 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xfe, 0xff, 0xff, 0x9f, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0x50, 0x9f, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0x40, 0x0, 0xdf, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x40, 0x0, + 0x2, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0x30, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf6, 0x0, + 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xf3, 0x0, 0x0, 0xcf, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xd0, 0x0, 0xc, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xa0, 0x0, 0xcf, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0x60, 0xc, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0x30, 0xcf, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xfd, 0x0, + + /* U+039B "Λ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xef, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0x6f, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xb, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xfb, 0x5, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf5, + 0x0, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf0, 0x0, + 0xaf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x90, 0x0, 0x4f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x30, 0x0, 0xe, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xfd, 0x0, 0x0, 0x9, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf7, 0x0, 0x0, 0x3, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x2f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x70, 0x0, 0x0, + 0x9f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xd0, 0x0, 0x0, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf4, 0x0, 0x6, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xfa, 0x0, 0xc, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0x10, 0x2f, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0x70, 0x9f, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xd0, + + /* U+039C "Μ" */ + 0xbf, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x5b, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf5, 0xbf, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x5b, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf5, 0xbf, 0xff, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xff, 0x5b, 0xff, 0xfb, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xfd, 0xff, 0xf5, 0xbf, 0xff, 0x6f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xfd, 0xaf, 0xff, 0x5b, 0xff, 0xf5, 0xaf, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0x7a, 0xff, 0xf5, 0xbf, 0xff, 0x55, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf2, 0xaf, 0xff, 0x5b, 0xff, 0xf5, 0xf, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfc, + 0xa, 0xff, 0xf5, 0xbf, 0xff, 0x50, 0xaf, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0x60, + 0xaf, 0xff, 0x5b, 0xff, 0xf5, 0x4, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf1, 0xa, + 0xff, 0xf5, 0xbf, 0xff, 0x50, 0xe, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfb, 0x0, 0xaf, + 0xff, 0x5b, 0xff, 0xf5, 0x0, 0x9f, 0xff, 0x20, + 0x0, 0x0, 0x0, 0xe, 0xff, 0x50, 0xa, 0xff, + 0xf5, 0xbf, 0xff, 0x50, 0x4, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xf0, 0x0, 0xaf, 0xff, + 0x5b, 0xff, 0xf5, 0x0, 0xe, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0xaf, 0xfa, 0x0, 0xa, 0xff, 0xf5, + 0xbf, 0xff, 0x50, 0x0, 0x9f, 0xff, 0x20, 0x0, + 0x0, 0xf, 0xff, 0x40, 0x0, 0xaf, 0xff, 0x5b, + 0xff, 0xf5, 0x0, 0x3, 0xff, 0xf8, 0x0, 0x0, + 0x5, 0xff, 0xe0, 0x0, 0xa, 0xff, 0xf5, 0xbf, + 0xff, 0x50, 0x0, 0xd, 0xff, 0xd0, 0x0, 0x0, + 0xbf, 0xf9, 0x0, 0x0, 0xaf, 0xff, 0x5b, 0xff, + 0xf5, 0x0, 0x0, 0x8f, 0xff, 0x30, 0x0, 0x1f, + 0xff, 0x40, 0x0, 0xa, 0xff, 0xf5, 0xbf, 0xff, + 0x50, 0x0, 0x3, 0xff, 0xf8, 0x0, 0x6, 0xff, + 0xe0, 0x0, 0x0, 0xaf, 0xff, 0x5b, 0xff, 0xf5, + 0x0, 0x0, 0xd, 0xff, 0xd0, 0x0, 0xcf, 0xf8, + 0x0, 0x0, 0xa, 0xff, 0xf5, 0xbf, 0xff, 0x50, + 0x0, 0x0, 0x7f, 0xff, 0x30, 0x1f, 0xff, 0x30, + 0x0, 0x0, 0xaf, 0xff, 0x5b, 0xff, 0xf5, 0x0, + 0x0, 0x2, 0xff, 0xf8, 0x7, 0xff, 0xd0, 0x0, + 0x0, 0xa, 0xff, 0xf5, 0xbf, 0xff, 0x50, 0x0, + 0x0, 0xc, 0xff, 0xd0, 0xcf, 0xf7, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0x5b, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x5f, 0xff, 0x20, 0x0, 0x0, + 0xa, 0xff, 0xf5, 0xbf, 0xff, 0x50, 0x0, 0x0, + 0x1, 0xff, 0xfe, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x5b, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf5, 0xbf, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0x5b, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf5, 0xbf, 0xff, 0x50, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x50, + + /* U+039D "Ν" */ + 0x8f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf4, 0x8f, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xf4, 0x8f, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf4, 0x8f, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf4, 0x8f, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf4, 0x8f, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xf4, 0x8f, 0xff, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf4, 0x8f, 0xff, 0x8e, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf4, + 0x8f, 0xff, 0x74, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf4, 0x8f, 0xff, 0x70, + 0x9f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xf4, 0x8f, 0xff, 0x70, 0xd, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf4, 0x8f, + 0xff, 0x70, 0x3, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf4, 0x8f, 0xff, 0x70, 0x0, + 0x8f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf4, 0x8f, 0xff, 0x70, 0x0, 0xd, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xf4, 0x8f, 0xff, + 0x70, 0x0, 0x3, 0xff, 0xff, 0x90, 0x0, 0x0, + 0xb, 0xff, 0xf4, 0x8f, 0xff, 0x70, 0x0, 0x0, + 0x8f, 0xff, 0xf4, 0x0, 0x0, 0xb, 0xff, 0xf4, + 0x8f, 0xff, 0x70, 0x0, 0x0, 0xc, 0xff, 0xfe, + 0x10, 0x0, 0xb, 0xff, 0xf4, 0x8f, 0xff, 0x70, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xa0, 0x0, 0xb, + 0xff, 0xf4, 0x8f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xf5, 0x0, 0xb, 0xff, 0xf4, 0x8f, + 0xff, 0x70, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfe, + 0x10, 0xb, 0xff, 0xf4, 0x8f, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xa0, 0xb, 0xff, + 0xf4, 0x8f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xf5, 0xb, 0xff, 0xf4, 0x8f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xfe, + 0x1b, 0xff, 0xf4, 0x8f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xbb, 0xff, 0xf4, + 0x8f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xf4, 0x8f, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xf4, 0x8f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xf4, 0x8f, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xf4, 0x8f, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xf4, 0x8f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xf4, 0x8f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xf4, + + /* U+039E "Ξ" */ + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0x1, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xa0, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0x60, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xa2, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x4a, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x40, + + /* U+039F "Ο" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x46, 0x77, + 0x65, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0x8d, 0xff, 0xff, 0xff, + 0xff, 0xea, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x19, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xfa, 0x53, 0x11, 0x24, 0x9e, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0x91, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xef, 0xff, 0xf4, 0x0, 0x0, 0xb, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xe0, 0x0, 0x3, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0x70, 0x0, 0xaf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfe, 0x0, 0xf, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf4, 0x4, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x90, 0x8f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xfc, 0xb, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xf0, 0xdf, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0x1e, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf2, + 0xef, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x2e, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf2, 0xdf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x1b, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf0, 0x8f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xfc, 0x4, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x90, 0xf, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xf4, 0x0, 0x9f, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xfe, 0x0, 0x3, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0x70, 0x0, 0xa, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xff, 0xe0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xdf, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xef, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xe9, + 0x42, 0x10, 0x24, 0x8d, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x18, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x7d, 0xff, 0xff, + 0xff, 0xff, 0xe9, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x46, 0x77, + 0x75, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A0 "Π" */ + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf3, 0x7f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf3, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x7f, + 0xff, 0xea, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaf, 0xff, 0xf3, 0x7f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf3, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, 0x7f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf3, 0x7f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, + 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf3, 0x7f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf3, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, 0x7f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf3, 0x7f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf3, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, 0x7f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf3, 0x7f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, + 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf3, 0x7f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf3, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, 0x7f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf3, 0x7f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf3, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, 0x7f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf3, 0x7f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, + 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf3, 0x7f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf3, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, 0x7f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf3, 0x7f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf3, 0x7f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, 0x7f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf3, + + /* U+03A1 "Ρ" */ + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xed, + 0xb9, 0x50, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x0, 0x9, 0xff, 0xfd, + 0xaa, 0xaa, 0xaa, 0xaa, 0xab, 0xcf, 0xff, 0xff, + 0xfa, 0x0, 0x9f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xef, 0xff, 0xf5, 0x9, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xc0, 0x9f, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x19, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf4, 0x9f, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x69, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf6, 0x9f, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0x59, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf2, 0x9f, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfd, 0x9, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x70, 0x9f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x14, 0x8e, + 0xff, 0xff, 0xd0, 0x9, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe3, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x70, 0x0, + 0x0, 0x9f, 0xff, 0xda, 0xaa, 0xaa, 0xaa, 0xaa, + 0x98, 0x52, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+03A3 "Σ" */ + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf9, 0xd, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf9, 0xd, 0xff, 0xff, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0x60, 0x7f, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xcf, 0xff, 0xe2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, + 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2e, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xfe, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xa5, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x7d, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf7, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x70, + + /* U+03A4 "Τ" */ + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0xf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xae, 0xff, 0xfd, 0xaa, + 0xaa, 0xaa, 0xaa, 0xa9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+03A5 "Υ" */ + 0x8f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xa0, 0xdf, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xe1, 0x3, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xf4, 0x0, 0x8, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf8, 0x0, 0x0, 0xc, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x3f, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x20, + 0x0, 0xd, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfc, 0x0, 0x7, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xf6, 0x2, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xe0, 0xbf, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xcf, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+03A6 "Φ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x11, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x59, + 0xce, 0xff, 0xff, 0xff, 0xfd, 0xc9, 0x51, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x19, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xfc, 0x87, 0xbf, 0xff, 0xc7, 0x8b, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xfe, 0x70, 0x0, 0x8, 0xff, 0xfa, 0x0, 0x0, + 0x6e, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x3f, 0xff, + 0xfc, 0x10, 0x0, 0x0, 0x8f, 0xff, 0xa0, 0x0, + 0x0, 0x1c, 0xff, 0xff, 0x60, 0x0, 0xc, 0xff, + 0xfd, 0x10, 0x0, 0x0, 0x8, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xfe, 0x0, 0x4, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf7, 0x0, 0x9f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, 0xd, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x0, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf2, + 0x2f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0x32, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf3, 0x1f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0x20, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf0, 0xb, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xfd, 0x0, 0x7f, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0x80, 0x1, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xf2, 0x0, 0x7, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x8, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xf9, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xc2, 0x0, 0x0, 0x8f, 0xff, 0xa0, 0x0, 0x0, + 0x8f, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x1d, 0xff, + 0xff, 0xfb, 0x62, 0x18, 0xff, 0xfa, 0x2, 0x59, + 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x1b, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6b, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x24, 0x5b, 0xff, 0xfc, + 0x54, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+03A7 "Χ" */ + 0x1, 0xef, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xfc, 0x0, 0x0, + 0x4f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xe2, 0x0, 0x0, 0x8, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfe, 0x10, + 0x0, 0x2, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xb0, 0x0, + 0xd, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf6, 0x0, 0x9f, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0x15, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xbe, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0x4e, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf9, 0x5, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xd0, 0x0, 0xaf, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0x30, 0x0, 0xd, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf6, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0x80, 0x0, 0x0, 0xdf, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf4, 0x0, 0xa, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xfe, 0x10, 0x6f, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xb0, + + /* U+03A8 "Ψ" */ + 0x4f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0x4, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xf0, 0x4f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x4, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xf0, 0x4f, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0x4, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf0, 0x4f, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x4, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf0, 0x4f, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0x3, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf0, 0x2f, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xfe, 0x1, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xd0, 0xe, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xfa, 0x0, 0xaf, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x60, 0x5, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf2, 0x0, + 0xe, 0xff, 0xfe, 0x20, 0x0, 0x0, 0xb, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfa, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0x60, 0x0, 0x0, 0xbf, + 0xff, 0x70, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xe9, 0x51, 0xb, + 0xff, 0xf7, 0x12, 0x59, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x6e, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xa4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0x56, 0x7d, 0xff, 0xfb, 0x76, 0x52, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A9 "Ω" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x57, 0x77, + 0x63, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0xb6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xe8, + 0x31, 0x1, 0x38, 0xef, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0x10, 0x0, 0xb, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xfa, 0x0, 0x3, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf2, 0x0, 0x9f, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0x80, 0xe, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xfd, 0x3, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf1, 0x5f, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0x47, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf6, 0x8f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x78, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf7, + 0x8f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x66, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xf5, 0x3f, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x20, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xe0, 0xb, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf9, + 0x0, 0x5f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x30, 0x0, + 0xdf, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xc0, 0x0, 0x4, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf3, 0x0, 0x0, 0xa, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0xd, 0xff, 0xe3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xef, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xe3, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xef, 0xfd, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x1d, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xfc, 0x10, 0x0, 0x0, 0x9a, 0xaa, + 0xaa, 0xbf, 0xff, 0xfe, 0x30, 0x0, 0x3e, 0xff, + 0xff, 0xba, 0xaa, 0xaa, 0x8e, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x6, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xde, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + + /* U+03AA "Ϊ" */ + 0x5, 0x55, 0x50, 0x0, 0x5, 0x55, 0x50, 0xf, + 0xff, 0xf0, 0x0, 0xf, 0xff, 0xf0, 0xf, 0xff, + 0xf0, 0x0, 0xf, 0xff, 0xf0, 0xf, 0xff, 0xf0, + 0x0, 0xf, 0xff, 0xf0, 0xf, 0xff, 0xf0, 0x0, + 0xf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf2, + 0x0, 0x0, + + /* U+03AB "Ϋ" */ + 0x0, 0x0, 0x0, 0x0, 0x25, 0x55, 0x30, 0x0, + 0x25, 0x55, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf9, 0x0, 0x7, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x90, 0x0, 0x7f, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xf9, 0x0, 0x7, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0x90, 0x0, 0x7f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xfa, 0xd, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xfe, 0x10, 0x3f, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0x40, 0x0, 0x8f, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x80, 0x0, + 0x0, 0xcf, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xc0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0xd, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf8, 0x0, 0x0, + 0x3, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf2, 0x0, 0x0, 0xdf, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xc0, 0x0, 0x7f, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0x60, 0x2f, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xfe, 0xb, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xfc, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03AC "ά" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x57, 0x76, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4c, 0xff, 0xff, 0xff, 0xe6, 0x0, + 0x5, 0xff, 0xfa, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xfa, 0x0, 0xaf, 0xff, 0x50, 0x0, + 0xaf, 0xff, 0xff, 0xdb, 0xbe, 0xff, 0xfa, 0xe, + 0xff, 0xf1, 0x0, 0x6f, 0xff, 0xfc, 0x20, 0x0, + 0x6, 0xff, 0xfa, 0xff, 0xfc, 0x0, 0x1f, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0x80, 0x7, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf4, 0x0, 0xcf, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x10, + 0xf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xd0, 0x3, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf9, 0x0, 0x5f, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x60, 0x6, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf3, 0x0, 0x7f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0x10, 0x6, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf3, 0x0, 0x5f, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x60, + 0x3, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xf9, 0x0, 0xf, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xc0, 0x0, + 0xcf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0x0, 0x6, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xf3, 0x0, 0xe, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x5f, 0xff, 0xfb, 0x10, 0x0, + 0x8, 0xff, 0xf7, 0xff, 0xfb, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xca, 0xbf, 0xff, 0xfa, 0xf, 0xff, + 0xf0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x0, 0xaf, 0xff, 0x40, 0x0, 0x0, 0x4c, + 0xff, 0xff, 0xff, 0xe7, 0x0, 0x4, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x1, 0x57, 0x76, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+03AD "έ" */ + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xe2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x57, + 0x76, 0x40, 0x0, 0x0, 0x0, 0x0, 0x3b, 0xff, + 0xff, 0xff, 0xfa, 0x20, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x2f, 0xff, + 0xff, 0xdd, 0xff, 0xff, 0xff, 0x70, 0xa, 0xff, + 0xfa, 0x10, 0x0, 0x5d, 0xff, 0xb0, 0x0, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x8, 0x80, 0x0, 0x3f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xc6, 0x43, 0x10, 0x0, + 0x0, 0x0, 0x4, 0xef, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xfe, 0x73, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xfe, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x2, 0x0, 0xa, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x3, 0xed, 0x20, 0x4f, 0xff, + 0xf9, 0x0, 0x0, 0x19, 0xff, 0xfe, 0x30, 0xbf, + 0xff, 0xfe, 0xba, 0xcf, 0xff, 0xff, 0xd1, 0x1, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x8e, 0xff, 0xff, 0xff, 0xfa, 0x30, 0x0, + 0x0, 0x0, 0x3, 0x67, 0x75, 0x40, 0x0, 0x0, + 0x0, + + /* U+03AE "ή" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xe3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0x57, 0x75, 0x10, + 0x0, 0x0, 0xf, 0xff, 0x70, 0x8, 0xef, 0xff, + 0xff, 0xfb, 0x30, 0x0, 0xf, 0xff, 0x72, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0xf, 0xff, + 0x8d, 0xff, 0xff, 0xdd, 0xff, 0xff, 0xff, 0x40, + 0xf, 0xff, 0xff, 0xfc, 0x40, 0x0, 0x6, 0xff, + 0xff, 0xc0, 0xf, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf1, 0xf, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf4, 0xf, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf6, + 0xf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf7, 0xf, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf8, 0xf, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, 0xf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, + 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf8, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf8, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, 0xf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, + 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf8, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf8, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, 0xf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, + 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf8, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf8, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, 0xf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf8, + + /* U+03AF "ί" */ + 0x0, 0x1e, 0xff, 0xfc, 0x0, 0x8, 0xff, 0xff, + 0x20, 0x1, 0xff, 0xff, 0x40, 0x0, 0x8f, 0xff, + 0x70, 0x0, 0xe, 0xff, 0xb0, 0x0, 0x7, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xfd, 0x0, 0x0, 0x1f, 0xff, 0xd0, + 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x1f, 0xff, + 0xd0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x1f, + 0xff, 0xd0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, + 0x1f, 0xff, 0xd0, 0x0, 0x1, 0xff, 0xfd, 0x0, + 0x0, 0x1f, 0xff, 0xd0, 0x0, 0x1, 0xff, 0xfd, + 0x0, 0x0, 0x1f, 0xff, 0xd0, 0x0, 0x1, 0xff, + 0xfd, 0x0, 0x0, 0x1f, 0xff, 0xd0, 0x0, 0x1, + 0xff, 0xfd, 0x0, 0x0, 0x1f, 0xff, 0xd0, 0x0, + 0x1, 0xff, 0xfd, 0x0, 0x0, 0x1f, 0xff, 0xd0, + 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x1f, 0xff, + 0xd0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x1f, + 0xff, 0xd0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, + + /* U+03B0 "ΰ" */ + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x11, 0x0, 0x8, 0xff, + 0xf2, 0x11, 0x11, 0x0, 0x0, 0xcf, 0xff, 0x0, + 0xe, 0xff, 0x60, 0xdf, 0xfe, 0x0, 0x0, 0xcf, + 0xff, 0x0, 0x7f, 0xfa, 0x0, 0xdf, 0xfe, 0x0, + 0x0, 0xcf, 0xff, 0x0, 0xef, 0xe1, 0x0, 0xdf, + 0xfe, 0x0, 0x0, 0xcf, 0xff, 0x6, 0xff, 0x30, + 0x0, 0xdf, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf3, 0x1f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf3, 0x1f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf3, + 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf3, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf3, 0x1f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf3, 0x1f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf3, + 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf3, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf3, 0x1f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf3, 0x1f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf3, + 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf3, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf3, 0x1f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf2, 0xf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf1, + 0xf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf0, 0xd, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xe0, 0xa, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xa0, 0x5, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x2, 0xef, 0xff, 0x40, + 0x0, 0xdf, 0xff, 0xe5, 0x0, 0x0, 0x5e, 0xff, + 0xfc, 0x0, 0x0, 0x2e, 0xff, 0xff, 0xeb, 0xbe, + 0xff, 0xff, 0xe2, 0x0, 0x0, 0x2, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, + 0x8, 0xef, 0xff, 0xff, 0xfe, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0x67, 0x76, 0x30, 0x0, + 0x0, 0x0, + + /* U+03B1 "α" */ + 0x0, 0x0, 0x0, 0x1, 0x57, 0x76, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4c, 0xff, + 0xff, 0xff, 0xe6, 0x0, 0x5, 0xff, 0xfa, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0xaf, 0xff, 0x50, 0x0, 0xaf, 0xff, 0xff, 0xdb, + 0xbe, 0xff, 0xfa, 0xe, 0xff, 0xf1, 0x0, 0x6f, + 0xff, 0xfc, 0x20, 0x0, 0x6, 0xff, 0xfa, 0xff, + 0xfc, 0x0, 0x1f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0x80, 0x7, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf4, + 0x0, 0xcf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0x10, 0xf, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xd0, 0x3, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf9, 0x0, 0x5f, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x60, 0x6, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf3, 0x0, 0x7f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0x10, 0x6, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf3, + 0x0, 0x5f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x60, 0x3, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf9, 0x0, + 0xf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xc0, 0x0, 0xcf, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, 0x6, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xf3, 0x0, 0xe, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0x70, 0x0, 0x5f, + 0xff, 0xfb, 0x10, 0x0, 0x8, 0xff, 0xf7, 0xff, + 0xfb, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xca, 0xbf, + 0xff, 0xfa, 0xf, 0xff, 0xf0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, 0xaf, 0xff, + 0x40, 0x0, 0x0, 0x4c, 0xff, 0xff, 0xff, 0xe7, + 0x0, 0x4, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x1, + 0x57, 0x76, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03B2 "β" */ + 0x0, 0x0, 0x0, 0x14, 0x67, 0x65, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xbf, 0xff, 0xff, + 0xff, 0xd5, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xeb, 0xab, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x9, 0xff, 0xfe, 0x50, 0x0, 0x0, + 0x7f, 0xff, 0xf4, 0x0, 0x2, 0xff, 0xfe, 0x20, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xc0, 0x0, 0x7f, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x20, 0xb, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf5, 0x0, 0xdf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x60, 0xf, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf5, + 0x0, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x10, 0xf, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xb0, 0x0, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x1c, 0xff, 0xe2, 0x0, + 0xf, 0xff, 0xd0, 0x0, 0x0, 0x25, 0x9f, 0xff, + 0xe3, 0x0, 0x0, 0xff, 0xfd, 0x0, 0xb, 0xff, + 0xff, 0xff, 0x81, 0x0, 0x0, 0xf, 0xff, 0xd0, + 0x0, 0xbf, 0xff, 0xff, 0xa6, 0x10, 0x0, 0x0, + 0xff, 0xfd, 0x0, 0x9, 0xcd, 0xff, 0xff, 0xff, + 0x80, 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x27, 0xef, 0xff, 0xd1, 0x0, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xcf, 0xff, 0xc0, 0xf, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xff, 0x60, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xfd, 0xf, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf1, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x3f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf4, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x3f, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf0, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xfc, 0xf, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0x50, 0xff, 0xff, + 0xff, 0xb1, 0x0, 0x0, 0x1, 0xcf, 0xff, 0xc0, + 0xf, 0xff, 0xec, 0xff, 0xfa, 0x65, 0x69, 0xff, + 0xff, 0xe1, 0x0, 0xff, 0xfd, 0xc, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe2, 0x0, 0xf, 0xff, 0xd0, + 0x6, 0xdf, 0xff, 0xff, 0xfe, 0x80, 0x0, 0x0, + 0xff, 0xfd, 0x0, 0x0, 0x35, 0x77, 0x63, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03B3 "γ" */ + 0x4f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf4, 0xe, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xe0, 0x8, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x80, 0x3, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x20, 0x0, 0xdf, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xfc, 0x0, 0x0, + 0x7f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf7, 0x0, 0x0, 0x1f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf1, 0x0, 0x0, 0xb, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xb0, 0x0, + 0x0, 0x5, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0x50, 0x0, 0x0, 0x0, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0xef, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x40, 0x0, 0x3, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x90, 0x0, 0x9, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xf0, 0x0, 0xe, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xf5, 0x0, 0x5f, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfa, 0x0, + 0xaf, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x1, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x66, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xbc, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + + /* U+03B4 "δ" */ + 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x5, 0xff, 0xff, 0x71, 0x11, 0x11, + 0x11, 0x11, 0x11, 0x0, 0x0, 0x0, 0x2c, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xef, 0xfd, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x19, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x39, 0xdf, 0xff, 0xff, 0xb1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1b, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x40, 0x0, 0x0, 0x0, 0x3, + 0xef, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0x81, 0x0, 0x4, + 0xcf, 0xff, 0x80, 0x0, 0x0, 0xcf, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf8, 0x0, 0x4, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x40, 0xb, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xd0, 0xf, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf4, + 0x2f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xf9, 0x5f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xfc, 0x6f, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xfd, 0x6f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xfe, 0x6f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfe, 0x5f, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xfd, 0x2f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xfc, 0xe, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf8, + 0xa, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xf4, 0x3, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xe0, 0x0, 0xbf, + 0xff, 0xd1, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0x60, 0x0, 0x2f, 0xff, 0xfe, 0x50, 0x0, 0x1, + 0x9f, 0xff, 0xfb, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xfe, 0xba, 0xcf, 0xff, 0xff, 0xc1, 0x0, 0x0, + 0x0, 0x4e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x9e, 0xff, 0xff, + 0xff, 0xfb, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x35, 0x77, 0x64, 0x0, 0x0, 0x0, 0x0, + + /* U+03B5 "ε" */ + 0x0, 0x0, 0x1, 0x57, 0x76, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x3b, 0xff, 0xff, 0xff, 0xfa, 0x20, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x2f, 0xff, 0xff, 0xdd, 0xff, 0xff, + 0xff, 0x70, 0xa, 0xff, 0xfa, 0x10, 0x0, 0x5d, + 0xff, 0xb0, 0x0, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x8, 0x80, 0x0, 0x3f, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xc6, 0x43, 0x10, 0x0, 0x0, 0x0, 0x4, 0xef, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x1d, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xfe, 0x73, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x2, + 0x0, 0xa, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x3, + 0xed, 0x20, 0x4f, 0xff, 0xf9, 0x0, 0x0, 0x19, + 0xff, 0xfe, 0x30, 0xbf, 0xff, 0xfe, 0xba, 0xcf, + 0xff, 0xff, 0xd1, 0x1, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x8e, 0xff, 0xff, + 0xff, 0xfa, 0x30, 0x0, 0x0, 0x0, 0x3, 0x67, + 0x75, 0x40, 0x0, 0x0, 0x0, + + /* U+03B6 "ζ" */ + 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x1, 0x11, + 0x11, 0x11, 0x1a, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2c, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, 0xd2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xc1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xeb, 0x97, 0x53, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xa2, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe3, 0x0, 0x0, 0x0, 0x39, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x27, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xef, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7b, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9e, + 0xc8, 0x30, 0x0, 0x0, + + /* U+03B7 "η" */ + 0x0, 0x0, 0x0, 0x0, 0x3, 0x57, 0x75, 0x10, + 0x0, 0x0, 0xf, 0xff, 0x70, 0x8, 0xef, 0xff, + 0xff, 0xfb, 0x30, 0x0, 0xf, 0xff, 0x72, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0xf, 0xff, + 0x8d, 0xff, 0xff, 0xdd, 0xff, 0xff, 0xff, 0x40, + 0xf, 0xff, 0xff, 0xfc, 0x40, 0x0, 0x6, 0xff, + 0xff, 0xc0, 0xf, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf1, 0xf, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf4, 0xf, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf6, + 0xf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf7, 0xf, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf8, 0xf, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, 0xf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, + 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf8, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf8, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, 0xf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, + 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf8, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf8, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, 0xf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, + 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf8, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf8, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, 0xf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf8, + + /* U+03B8 "θ" */ + 0x0, 0x0, 0x0, 0x0, 0x25, 0x67, 0x53, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4c, 0xff, + 0xff, 0xff, 0xe9, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe3, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, 0xba, 0xdf, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x60, 0x0, 0x2, 0xcf, 0xff, 0xd0, 0x0, 0x0, + 0xe, 0xff, 0xf5, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf7, 0x0, 0x0, 0x7f, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xfe, 0x0, 0x0, 0xcf, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x40, + 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x90, 0x5, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x8, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xf0, 0xa, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf2, 0xd, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf4, 0xe, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xf6, 0xe, 0xff, 0xf1, 0x11, 0x11, 0x11, + 0x11, 0x11, 0x18, 0xff, 0xf6, 0xf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf8, 0xf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xe, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xf6, 0xe, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf6, 0xd, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf4, 0xa, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf2, 0x8, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf0, 0x5, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xd0, + 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x90, 0x0, 0xcf, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x40, 0x0, 0x7f, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfe, + 0x0, 0x0, 0xe, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xf7, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x70, 0x0, 0x2, 0xcf, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xfe, 0xba, 0xcf, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4c, 0xff, 0xff, 0xff, 0xe9, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x25, 0x67, 0x54, 0x0, + 0x0, 0x0, 0x0, + + /* U+03B9 "ι" */ + 0x1f, 0xff, 0xd1, 0xff, 0xfd, 0x1f, 0xff, 0xd1, + 0xff, 0xfd, 0x1f, 0xff, 0xd1, 0xff, 0xfd, 0x1f, + 0xff, 0xd1, 0xff, 0xfd, 0x1f, 0xff, 0xd1, 0xff, + 0xfd, 0x1f, 0xff, 0xd1, 0xff, 0xfd, 0x1f, 0xff, + 0xd1, 0xff, 0xfd, 0x1f, 0xff, 0xd1, 0xff, 0xfd, + 0x1f, 0xff, 0xd1, 0xff, 0xfd, 0x1f, 0xff, 0xd1, + 0xff, 0xfd, 0x1f, 0xff, 0xd1, 0xff, 0xfd, 0x1f, + 0xff, 0xd0, + + /* U+03BA "κ" */ + 0x2f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0x80, 0x2f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xf7, 0x0, 0x2f, 0xff, 0xb0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0x60, 0x0, 0x2f, 0xff, + 0xb0, 0x0, 0x0, 0x9f, 0xff, 0xf5, 0x0, 0x0, + 0x2f, 0xff, 0xb0, 0x0, 0x9, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x2f, 0xff, 0xb0, 0x0, 0xaf, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xb0, 0xa, + 0xff, 0xfe, 0x30, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xb0, 0xaf, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xbb, 0xff, 0xfd, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xfb, 0x9f, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xd0, 0xb, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xb0, 0x1, + 0xdf, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xb0, 0x0, 0x2f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xb0, 0x0, 0x5, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x2f, 0xff, 0xb0, 0x0, 0x0, 0x7f, + 0xff, 0xf7, 0x0, 0x0, 0x2f, 0xff, 0xb0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0x40, 0x0, 0x2f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf2, 0x0, + 0x2f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xfd, 0x10, 0x2f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xb0, 0x2f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf9, + + /* U+03BB "λ" */ + 0x0, 0x0, 0x3, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xde, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0x78, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x12, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xfb, + 0x0, 0xcf, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf5, 0x0, 0x6f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xe0, 0x0, 0xf, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0x90, 0x0, 0x9, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x30, 0x0, 0x3, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x30, 0x0, 0x0, 0x9, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x90, 0x0, + 0x0, 0xf, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xe0, 0x0, 0x0, 0x5f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf5, 0x0, 0x0, 0xcf, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfb, + 0x0, 0x2, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0x10, 0x8, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x70, 0xe, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xd0, 0x4f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xf3, + + /* U+03BC "μ" */ + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0x7f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf7, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x7f, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf7, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x7f, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xf7, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0x7f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf7, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x7f, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf7, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x7f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf7, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0x7f, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf7, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x7f, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf7, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0x7f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xf7, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xfb, + 0x30, 0x2, 0x8f, 0xff, 0xff, 0xf7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0xff, 0x7f, + 0xff, 0xd7, 0xff, 0xff, 0xff, 0xff, 0xe2, 0xff, + 0xf7, 0xff, 0xfd, 0x5, 0xef, 0xff, 0xff, 0xb1, + 0xf, 0xff, 0x7f, 0xff, 0xd0, 0x0, 0x46, 0x75, + 0x10, 0x0, 0x0, 0x0, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03BD "ν" */ + 0x4f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf4, 0xd, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xe0, 0x7, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x80, 0x2, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x20, 0x0, 0xbf, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xfc, 0x0, 0x0, + 0x5f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf6, 0x0, 0x0, 0xf, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf1, 0x0, 0x0, 0x9, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xa0, 0x0, + 0x0, 0x3, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x0, + 0x0, 0x0, 0xef, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x60, 0x0, 0x4, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xb0, 0x0, 0xa, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf1, 0x0, 0xf, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf7, 0x0, 0x5f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfc, 0x0, + 0xbf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0x11, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x66, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xbb, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, + + /* U+03BE "ξ" */ + 0x0, 0x0, 0x0, 0x16, 0xad, 0xef, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0xb, 0xff, 0xff, 0xa6, + 0x43, 0x22, 0x21, 0x0, 0x0, 0x4f, 0xff, 0xd2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xfd, 0x73, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x8, 0xef, + 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x1a, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xfa, 0x64, 0x30, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xfd, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf7, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xfc, 0xa7, 0x51, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc4, 0x0, 0x0, 0x0, + 0x2a, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x16, 0xad, 0xff, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x8f, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1c, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8b, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xfe, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xb2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xec, 0x93, 0x0, + 0x0, + + /* U+03BF "ο" */ + 0x0, 0x0, 0x0, 0x0, 0x25, 0x67, 0x64, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7d, 0xff, + 0xff, 0xff, 0xfb, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xfe, 0xbb, 0xcf, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x3f, 0xff, 0xfd, + 0x40, 0x0, 0x1, 0x9f, 0xff, 0xf9, 0x0, 0x0, + 0xef, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0x40, 0x6, 0xff, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xc0, 0xc, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, + 0xf, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf7, 0x3f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xfb, 0x5f, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xfc, 0x6f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xfd, 0x7f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfe, 0x6f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xfd, 0x5f, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xfc, 0x3f, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfa, + 0xf, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf6, 0xb, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf2, 0x5, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xc0, 0x0, 0xdf, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0x50, 0x0, 0x3f, 0xff, 0xfd, + 0x40, 0x0, 0x1, 0x8f, 0xff, 0xfa, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xfe, 0xba, 0xcf, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x4e, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7e, 0xff, 0xff, 0xff, 0xfb, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x25, 0x77, 0x64, 0x0, + 0x0, 0x0, 0x0, + + /* U+03C0 "π" */ + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0xf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0xf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf6, 0x1, 0x11, 0x11, + 0x1f, 0xff, 0xd1, 0x11, 0x11, 0x11, 0x11, 0xbf, + 0xff, 0x41, 0x11, 0x10, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x30, 0x0, + 0x0, + + /* U+03C1 "ρ" */ + 0x0, 0x0, 0x0, 0x0, 0x46, 0x76, 0x52, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xaf, 0xff, + 0xff, 0xff, 0xd7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd3, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xfd, 0xbb, 0xef, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x2f, 0xff, 0xfc, + 0x30, 0x0, 0x4, 0xdf, 0xff, 0xe1, 0x0, 0x0, + 0xcf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xfb, 0x0, 0x2, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x30, 0x7, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xa0, + 0xb, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf0, 0xe, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf3, 0xf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf5, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xf6, 0x2f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf7, 0x2f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xf6, 0x3f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf5, 0x3f, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf3, + 0x3f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf0, 0x3f, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xb0, 0x3f, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x40, 0x3f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xfc, 0x0, 0x3f, 0xff, 0xff, 0xfb, + 0x20, 0x0, 0x2, 0xcf, 0xff, 0xf2, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xfd, 0xab, 0xdf, 0xff, 0xff, + 0x50, 0x0, 0x3f, 0xff, 0xb8, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x3f, 0xff, 0xb0, + 0x4c, 0xff, 0xff, 0xff, 0xf9, 0x10, 0x0, 0x0, + 0x3f, 0xff, 0xb0, 0x0, 0x15, 0x67, 0x64, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+03C2 "ς" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x56, 0x76, + 0x53, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5b, 0xff, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x5d, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xcb, 0xbc, 0xdf, 0xf1, + 0x0, 0x0, 0xaf, 0xff, 0xfa, 0x30, 0x0, 0x0, + 0x1, 0x40, 0x0, 0x7, 0xff, 0xfe, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xfd, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xfe, 0x94, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xfb, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xdf, 0xff, 0xff, + 0xff, 0xfe, 0x50, 0x0, 0x0, 0x0, 0x0, 0x4, + 0x9d, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x25, 0xaf, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xdf, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x20, 0x2, 0x6d, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xb3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0x67, 0x87, 0x51, 0x0, + 0x0, 0x0, + + /* U+03C3 "σ" */ + 0x0, 0x0, 0x0, 0x0, 0x25, 0x77, 0x63, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x4e, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0x6, 0xff, 0xff, 0xfd, 0xbb, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf3, 0x0, 0x4f, 0xff, 0xfc, + 0x30, 0x0, 0x1, 0x8f, 0xff, 0xf6, 0x11, 0x11, + 0x10, 0x0, 0xef, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0x20, 0x0, 0x0, 0x6, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xa0, 0x0, 0x0, 0xd, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf1, 0x0, 0x0, + 0x1f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf5, 0x0, 0x0, 0x4f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf9, + 0x0, 0x0, 0x6f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xfb, 0x0, 0x0, 0x7f, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xfc, 0x0, 0x0, 0x8f, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, + 0x0, 0x7f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xfc, 0x0, 0x0, 0x6f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xfb, 0x0, 0x0, 0x4f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf9, 0x0, 0x0, + 0x1f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf6, 0x0, 0x0, 0xd, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf2, + 0x0, 0x0, 0x6, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfc, + 0x30, 0x0, 0x1, 0x9f, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xfd, 0xba, 0xcf, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x8e, 0xff, + 0xff, 0xff, 0xfa, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x35, 0x77, 0x64, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03C4 "τ" */ + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x60, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf6, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x60, 0x11, 0x11, 0x11, 0xff, 0xfe, 0x11, + 0x11, 0x10, 0x0, 0x0, 0x0, 0xf, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xe0, 0x0, 0x0, 0x0, + + /* U+03C5 "υ" */ + 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf3, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf3, 0x1f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf3, 0x1f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf3, + 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf3, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf3, 0x1f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf3, 0x1f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf3, + 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf3, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf3, 0x1f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf3, 0x1f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf3, + 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf3, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf2, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xf1, 0xf, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf0, + 0xd, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xe0, 0xa, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xa0, 0x5, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x2, 0xef, 0xff, 0x40, 0x0, 0xdf, + 0xff, 0xe5, 0x0, 0x0, 0x5e, 0xff, 0xfc, 0x0, + 0x0, 0x2e, 0xff, 0xff, 0xeb, 0xbe, 0xff, 0xff, + 0xe2, 0x0, 0x0, 0x2, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, 0x8, 0xef, + 0xff, 0xff, 0xfe, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0x67, 0x76, 0x30, 0x0, 0x0, 0x0, + + /* U+03C6 "φ" */ + 0x0, 0x0, 0x0, 0x2, 0x54, 0x0, 0x0, 0x36, + 0x77, 0x41, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xcf, 0xf7, 0x0, 0x1c, 0xff, 0xff, 0xff, 0xb3, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf4, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf0, 0x3, 0xff, 0xff, 0xeb, + 0xdf, 0xff, 0xf4, 0x0, 0x0, 0x4f, 0xff, 0xf9, + 0x10, 0x6, 0xff, 0xfd, 0x0, 0x6, 0xff, 0xfe, + 0x10, 0x0, 0xef, 0xff, 0x70, 0x0, 0x7, 0xff, + 0xf8, 0x0, 0x0, 0x7f, 0xff, 0x80, 0x6, 0xff, + 0xfb, 0x0, 0x0, 0x7, 0xff, 0xf6, 0x0, 0x0, + 0xd, 0xff, 0xf0, 0xc, 0xff, 0xf3, 0x0, 0x0, + 0x8, 0xff, 0xf5, 0x0, 0x0, 0x7, 0xff, 0xf5, + 0xf, 0xff, 0xe0, 0x0, 0x0, 0x8, 0xff, 0xf5, + 0x0, 0x0, 0x4, 0xff, 0xfa, 0x4f, 0xff, 0xb0, + 0x0, 0x0, 0x8, 0xff, 0xf5, 0x0, 0x0, 0x2, + 0xff, 0xfd, 0x5f, 0xff, 0x90, 0x0, 0x0, 0x8, + 0xff, 0xf5, 0x0, 0x0, 0x1, 0xff, 0xff, 0x6f, + 0xff, 0x80, 0x0, 0x0, 0x8, 0xff, 0xf5, 0x0, + 0x0, 0x1, 0xff, 0xff, 0x6f, 0xff, 0x90, 0x0, + 0x0, 0x8, 0xff, 0xf5, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x5f, 0xff, 0xa0, 0x0, 0x0, 0x8, 0xff, + 0xf5, 0x0, 0x0, 0x4, 0xff, 0xfd, 0x3f, 0xff, + 0xd0, 0x0, 0x0, 0x8, 0xff, 0xf5, 0x0, 0x0, + 0x7, 0xff, 0xfa, 0xf, 0xff, 0xf2, 0x0, 0x0, + 0x8, 0xff, 0xf5, 0x0, 0x0, 0xc, 0xff, 0xf5, + 0xb, 0xff, 0xf9, 0x0, 0x0, 0x8, 0xff, 0xf5, + 0x0, 0x0, 0x3f, 0xff, 0xf0, 0x5, 0xff, 0xff, + 0x20, 0x0, 0x8, 0xff, 0xf5, 0x0, 0x0, 0xcf, + 0xff, 0x90, 0x0, 0xcf, 0xff, 0xd1, 0x0, 0x8, + 0xff, 0xf5, 0x0, 0x9, 0xff, 0xfe, 0x10, 0x0, + 0x3f, 0xff, 0xfd, 0x20, 0x8, 0xff, 0xf5, 0x0, + 0x9f, 0xff, 0xf5, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xf9, 0x38, 0xff, 0xf7, 0x6e, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xef, + 0xff, 0xff, 0xff, 0xfd, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0x6b, 0xff, 0xf9, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03C7 "χ" */ + 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xfe, 0x10, 0x3f, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x70, 0x0, + 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xe0, 0x0, 0x2, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, 0xa, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x4, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x50, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0x60, 0x0, 0x0, 0x4f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xfe, 0x0, 0x0, 0xc, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf6, 0x0, 0x4, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xd0, 0x0, 0xcf, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0x60, 0x5f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xfd, 0xd, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfa, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xfe, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x3f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x90, 0x8f, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf1, 0x1, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xf8, 0x0, 0x8, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0x10, 0x0, 0x1f, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0x80, 0x0, 0x0, 0x8f, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf1, 0x0, 0x0, 0x1, 0xff, + 0xff, 0x20, 0x0, 0x0, 0xa, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xfb, 0x0, 0x0, 0x3, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xf3, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xc0, 0x0, 0x4f, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x50, 0xd, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xfd, 0x5, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf6, + + /* U+03C8 "ψ" */ + 0x6f, 0xff, 0x70, 0x0, 0x0, 0x4, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xb6, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xa0, 0x0, 0x0, + 0x2, 0xff, 0xfb, 0x6f, 0xff, 0x70, 0x0, 0x0, + 0x4, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xb6, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xa0, 0x0, 0x0, 0x2, 0xff, 0xfb, 0x6f, 0xff, + 0x70, 0x0, 0x0, 0x4, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xb6, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xa0, 0x0, 0x0, 0x2, 0xff, + 0xfb, 0x6f, 0xff, 0x70, 0x0, 0x0, 0x4, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xb6, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xa0, 0x0, + 0x0, 0x2, 0xff, 0xfb, 0x6f, 0xff, 0x70, 0x0, + 0x0, 0x4, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xb6, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xa0, 0x0, 0x0, 0x2, 0xff, 0xfb, 0x6f, + 0xff, 0x70, 0x0, 0x0, 0x4, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xb5, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xa0, 0x0, 0x0, 0x2, + 0xff, 0xfb, 0x5f, 0xff, 0x70, 0x0, 0x0, 0x4, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xa5, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xa0, + 0x0, 0x0, 0x3, 0xff, 0xfa, 0x4f, 0xff, 0xa0, + 0x0, 0x0, 0x4, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x92, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xa0, 0x0, 0x0, 0x7, 0xff, 0xf7, + 0xf, 0xff, 0xf1, 0x0, 0x0, 0x4, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x40, 0xaf, 0xff, + 0x80, 0x0, 0x0, 0x4f, 0xff, 0xa0, 0x0, 0x0, + 0x3f, 0xff, 0xf0, 0x3, 0xff, 0xff, 0x50, 0x0, + 0x4, 0xff, 0xfa, 0x0, 0x0, 0x2e, 0xff, 0xfa, + 0x0, 0x9, 0xff, 0xff, 0xa2, 0x0, 0x4f, 0xff, + 0xa0, 0x1, 0x7f, 0xff, 0xff, 0x20, 0x0, 0xb, + 0xff, 0xff, 0xfe, 0xcc, 0xff, 0xfe, 0xbd, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x30, + 0x0, 0x0, 0x0, 0x2, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0x56, 0x9f, 0xff, 0xc7, 0x64, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03C9 "ω" */ + 0x0, 0x0, 0xef, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x50, 0x0, + 0x0, 0x7, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0xe, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf5, 0x0, + 0x0, 0x6f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfb, 0x0, + 0x0, 0xbf, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x10, + 0x1, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x22, + 0x22, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x70, + 0x6, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xb0, + 0x9, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf0, + 0xd, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x10, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf2, + 0xf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x10, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf4, + 0xf, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf6, + 0x1f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf7, + 0x1f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf7, + 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf6, + 0xf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x20, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf5, + 0xc, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0x40, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf2, + 0x9, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf0, + 0x4, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xa0, + 0x0, 0xef, 0xff, 0x60, 0x0, 0x0, 0x1e, 0xff, + 0xdf, 0xf5, 0x0, 0x0, 0x1, 0xef, 0xff, 0x40, + 0x0, 0x5f, 0xff, 0xf4, 0x0, 0x1, 0xcf, 0xfa, + 0x4f, 0xff, 0x40, 0x0, 0x1c, 0xff, 0xfb, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xb8, 0xaf, 0xff, 0xe1, + 0xa, 0xff, 0xfb, 0x8a, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0x30, + 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xb2, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xb1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0x67, 0x62, 0x0, 0x0, + 0x0, 0x0, 0x15, 0x77, 0x51, 0x0, 0x0, 0x0, + + /* U+03CA "ϊ" */ + 0x3f, 0xff, 0xd0, 0x0, 0x2f, 0xff, 0xe3, 0xff, + 0xfd, 0x0, 0x2, 0xff, 0xfe, 0x3f, 0xff, 0xd0, + 0x0, 0x2f, 0xff, 0xe3, 0xff, 0xfd, 0x0, 0x2, + 0xff, 0xfe, 0x15, 0x55, 0x40, 0x0, 0x5, 0x55, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xd0, + 0x0, 0x0, + + /* U+03CB "ϋ" */ + 0x0, 0x0, 0xff, 0xff, 0x10, 0x0, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0xff, 0xff, 0x10, 0x0, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0xff, 0xff, + 0x10, 0x0, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0xff, 0xff, 0x10, 0x0, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x55, 0x55, 0x0, 0x0, 0x55, 0x55, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf3, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf3, 0x1f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf3, 0x1f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf3, + 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf3, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf3, 0x1f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf3, 0x1f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf3, + 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf3, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf3, 0x1f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf3, 0x1f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf3, + 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf3, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf2, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xf1, 0xf, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf0, + 0xd, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xe0, 0xa, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xa0, 0x5, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x2, 0xef, 0xff, 0x40, 0x0, 0xdf, + 0xff, 0xe5, 0x0, 0x0, 0x5e, 0xff, 0xfc, 0x0, + 0x0, 0x2e, 0xff, 0xff, 0xeb, 0xbe, 0xff, 0xff, + 0xe2, 0x0, 0x0, 0x2, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, 0x8, 0xef, + 0xff, 0xff, 0xfe, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0x67, 0x76, 0x30, 0x0, 0x0, 0x0, + + /* U+03CC "ό" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x25, 0x67, 0x64, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7d, 0xff, + 0xff, 0xff, 0xfb, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xfe, 0xbb, 0xcf, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x3f, 0xff, 0xfd, + 0x40, 0x0, 0x1, 0x9f, 0xff, 0xf9, 0x0, 0x0, + 0xef, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0x40, 0x6, 0xff, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xc0, 0xc, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, + 0xf, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf7, 0x3f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xfb, 0x5f, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xfc, 0x6f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xfd, 0x7f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfe, 0x6f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xfd, 0x5f, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xfc, 0x3f, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfa, + 0xf, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf6, 0xb, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf2, 0x5, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xc0, 0x0, 0xdf, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0x50, 0x0, 0x3f, 0xff, 0xfd, + 0x40, 0x0, 0x1, 0x8f, 0xff, 0xfa, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xfe, 0xba, 0xcf, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x4e, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7e, 0xff, 0xff, 0xff, 0xfb, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x25, 0x77, 0x64, 0x0, + 0x0, 0x0, 0x0, + + /* U+03CD "ύ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf3, 0x1f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf3, 0x1f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf3, + 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf3, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf3, 0x1f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf3, 0x1f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf3, + 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf3, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf3, 0x1f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf3, 0x1f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf3, + 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf3, 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf3, 0x1f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf2, 0xf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf1, + 0xf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf0, 0xd, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xe0, 0xa, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xa0, 0x5, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x2, 0xef, 0xff, 0x40, + 0x0, 0xdf, 0xff, 0xe5, 0x0, 0x0, 0x5e, 0xff, + 0xfc, 0x0, 0x0, 0x2e, 0xff, 0xff, 0xeb, 0xbe, + 0xff, 0xff, 0xe2, 0x0, 0x0, 0x2, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, + 0x8, 0xef, 0xff, 0xff, 0xfe, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0x67, 0x76, 0x30, 0x0, + 0x0, 0x0, + + /* U+03CE "ώ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x50, 0x0, + 0x0, 0x7, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xd0, 0x0, + 0x0, 0xe, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf5, 0x0, + 0x0, 0x6f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfb, 0x0, + 0x0, 0xbf, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x10, + 0x1, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x22, + 0x22, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x70, + 0x6, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xb0, + 0x9, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf0, + 0xd, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x10, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf2, + 0xf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x10, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf4, + 0xf, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf6, + 0x1f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf7, + 0x1f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf7, + 0xf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf6, + 0xf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x20, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf5, + 0xc, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0x40, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf2, + 0x9, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf0, + 0x4, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xa0, + 0x0, 0xef, 0xff, 0x60, 0x0, 0x0, 0x1e, 0xff, + 0xdf, 0xf5, 0x0, 0x0, 0x1, 0xef, 0xff, 0x40, + 0x0, 0x5f, 0xff, 0xf4, 0x0, 0x1, 0xcf, 0xfa, + 0x4f, 0xff, 0x40, 0x0, 0x1c, 0xff, 0xfb, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xb8, 0xaf, 0xff, 0xe1, + 0xa, 0xff, 0xfb, 0x8a, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0x30, + 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xb2, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xb1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0x67, 0x62, 0x0, 0x0, + 0x0, 0x0, 0x15, 0x77, 0x51, 0x0, 0x0, 0x0, + + /* U+03F4 "ϴ" */ + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x20, 0x0, + 0x0, 0x11, 0x10, 0x0, 0x4f, 0xff, 0x60, 0x11, + 0x10, 0x7f, 0xff, 0x40, 0xb, 0xff, 0xa0, 0x9f, + 0xff, 0x27, 0xff, 0xf4, 0x3, 0xff, 0xe1, 0x9, + 0xff, 0xf2, 0x7f, 0xff, 0x40, 0xaf, 0xf3, 0x0, + 0x9f, 0xff, 0x27, 0xff, 0xf4, 0x2f, 0xf8, 0x0, + 0x9, 0xff, 0xf2 +}; + + +/*--------------------- + * GLYPH DESCRIPTION + *--------------------*/ + +static const lv_font_fmt_txt_glyph_dsc_t glyph_dsc[] = { + {.bitmap_index = 0, .adv_w = 0, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0} /* id = 0 reserved */, + {.bitmap_index = 0, .adv_w = 196, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 0, .adv_w = 196, .box_w = 6, .box_h = 31, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 93, .adv_w = 250, .box_w = 12, .box_h = 11, .ofs_x = 2, .ofs_y = 20}, + {.bitmap_index = 159, .adv_w = 392, .box_w = 24, .box_h = 33, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 555, .adv_w = 392, .box_w = 22, .box_h = 39, .ofs_x = 1, .ofs_y = -5}, + {.bitmap_index = 984, .adv_w = 626, .box_w = 35, .box_h = 33, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 1562, .adv_w = 470, .box_w = 28, .box_h = 33, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 2024, .adv_w = 133, .box_w = 5, .box_h = 11, .ofs_x = 2, .ofs_y = 20}, + {.bitmap_index = 2052, .adv_w = 235, .box_w = 12, .box_h = 41, .ofs_x = 2, .ofs_y = -9}, + {.bitmap_index = 2298, .adv_w = 235, .box_w = 11, .box_h = 41, .ofs_x = 1, .ofs_y = -9}, + {.bitmap_index = 2524, .adv_w = 274, .box_w = 15, .box_h = 14, .ofs_x = 1, .ofs_y = 18}, + {.bitmap_index = 2629, .adv_w = 411, .box_w = 22, .box_h = 21, .ofs_x = 2, .ofs_y = 5}, + {.bitmap_index = 2860, .adv_w = 196, .box_w = 6, .box_h = 12, .ofs_x = 3, .ofs_y = -7}, + {.bitmap_index = 2896, .adv_w = 234, .box_w = 13, .box_h = 4, .ofs_x = 1, .ofs_y = 9}, + {.bitmap_index = 2922, .adv_w = 196, .box_w = 6, .box_h = 5, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 2937, .adv_w = 196, .box_w = 13, .box_h = 32, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 3145, .adv_w = 392, .box_w = 22, .box_h = 32, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 3497, .adv_w = 392, .box_w = 13, .box_h = 31, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 3699, .adv_w = 392, .box_w = 22, .box_h = 31, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4040, .adv_w = 392, .box_w = 22, .box_h = 32, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 4392, .adv_w = 392, .box_w = 23, .box_h = 31, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 4749, .adv_w = 392, .box_w = 22, .box_h = 32, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 5101, .adv_w = 392, .box_w = 22, .box_h = 32, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 5453, .adv_w = 392, .box_w = 21, .box_h = 31, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 5779, .adv_w = 392, .box_w = 22, .box_h = 32, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 6131, .adv_w = 392, .box_w = 22, .box_h = 32, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 6483, .adv_w = 196, .box_w = 6, .box_h = 23, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 6552, .adv_w = 196, .box_w = 6, .box_h = 30, .ofs_x = 3, .ofs_y = -7}, + {.bitmap_index = 6642, .adv_w = 411, .box_w = 22, .box_h = 22, .ofs_x = 2, .ofs_y = 4}, + {.bitmap_index = 6884, .adv_w = 411, .box_w = 22, .box_h = 13, .ofs_x = 2, .ofs_y = 9}, + {.bitmap_index = 7027, .adv_w = 411, .box_w = 22, .box_h = 22, .ofs_x = 2, .ofs_y = 4}, + {.bitmap_index = 7269, .adv_w = 392, .box_w = 21, .box_h = 32, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 7605, .adv_w = 715, .box_w = 42, .box_h = 42, .ofs_x = 2, .ofs_y = -10}, + {.bitmap_index = 8487, .adv_w = 470, .box_w = 31, .box_h = 31, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 8968, .adv_w = 470, .box_w = 25, .box_h = 31, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 9356, .adv_w = 508, .box_w = 29, .box_h = 33, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 9835, .adv_w = 508, .box_w = 27, .box_h = 31, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 10254, .adv_w = 470, .box_w = 24, .box_h = 31, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 10626, .adv_w = 431, .box_w = 22, .box_h = 31, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 10967, .adv_w = 548, .box_w = 30, .box_h = 33, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 11462, .adv_w = 508, .box_w = 26, .box_h = 31, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 11865, .adv_w = 196, .box_w = 5, .box_h = 31, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 11943, .adv_w = 352, .box_w = 18, .box_h = 32, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 12231, .adv_w = 470, .box_w = 27, .box_h = 31, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 12650, .adv_w = 392, .box_w = 20, .box_h = 31, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 12960, .adv_w = 586, .box_w = 31, .box_h = 31, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 13441, .adv_w = 508, .box_w = 26, .box_h = 31, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 13844, .adv_w = 548, .box_w = 31, .box_h = 33, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 14356, .adv_w = 470, .box_w = 25, .box_h = 31, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 14744, .adv_w = 548, .box_w = 31, .box_h = 35, .ofs_x = 2, .ofs_y = -3}, + {.bitmap_index = 15287, .adv_w = 508, .box_w = 29, .box_h = 31, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 15737, .adv_w = 470, .box_w = 27, .box_h = 33, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 16183, .adv_w = 431, .box_w = 26, .box_h = 31, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 16586, .adv_w = 508, .box_w = 26, .box_h = 32, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 17002, .adv_w = 470, .box_w = 30, .box_h = 31, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 17467, .adv_w = 664, .box_w = 41, .box_h = 31, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 18103, .adv_w = 470, .box_w = 30, .box_h = 31, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 18568, .adv_w = 470, .box_w = 29, .box_h = 31, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 19018, .adv_w = 431, .box_w = 26, .box_h = 31, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 19421, .adv_w = 196, .box_w = 10, .box_h = 40, .ofs_x = 2, .ofs_y = -9}, + {.bitmap_index = 19621, .adv_w = 196, .box_w = 13, .box_h = 32, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 19829, .adv_w = 196, .box_w = 10, .box_h = 40, .ofs_x = 0, .ofs_y = -9}, + {.bitmap_index = 20029, .adv_w = 330, .box_w = 19, .box_h = 17, .ofs_x = 1, .ofs_y = 15}, + {.bitmap_index = 20191, .adv_w = 392, .box_w = 26, .box_h = 3, .ofs_x = -1, .ofs_y = -9}, + {.bitmap_index = 20230, .adv_w = 234, .box_w = 9, .box_h = 6, .ofs_x = 1, .ofs_y = 25}, + {.bitmap_index = 20257, .adv_w = 392, .box_w = 22, .box_h = 25, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 20532, .adv_w = 392, .box_w = 21, .box_h = 32, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 20868, .adv_w = 352, .box_w = 21, .box_h = 25, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 21131, .adv_w = 392, .box_w = 21, .box_h = 32, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 21467, .adv_w = 392, .box_w = 22, .box_h = 25, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 21742, .adv_w = 196, .box_w = 14, .box_h = 32, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 21966, .adv_w = 392, .box_w = 21, .box_h = 34, .ofs_x = 1, .ofs_y = -10}, + {.bitmap_index = 22323, .adv_w = 392, .box_w = 20, .box_h = 31, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 22633, .adv_w = 156, .box_w = 5, .box_h = 31, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 22711, .adv_w = 156, .box_w = 9, .box_h = 41, .ofs_x = -2, .ofs_y = -10}, + {.bitmap_index = 22896, .adv_w = 352, .box_w = 20, .box_h = 31, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 23206, .adv_w = 156, .box_w = 5, .box_h = 31, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 23284, .adv_w = 586, .box_w = 32, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 23668, .adv_w = 392, .box_w = 20, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 23908, .adv_w = 392, .box_w = 22, .box_h = 25, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 24183, .adv_w = 392, .box_w = 21, .box_h = 33, .ofs_x = 2, .ofs_y = -9}, + {.bitmap_index = 24530, .adv_w = 392, .box_w = 21, .box_h = 33, .ofs_x = 1, .ofs_y = -9}, + {.bitmap_index = 24877, .adv_w = 235, .box_w = 14, .box_h = 24, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 25045, .adv_w = 352, .box_w = 20, .box_h = 25, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 25295, .adv_w = 196, .box_w = 12, .box_h = 32, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 25487, .adv_w = 392, .box_w = 20, .box_h = 24, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 25727, .adv_w = 352, .box_w = 22, .box_h = 23, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 25980, .adv_w = 508, .box_w = 32, .box_h = 23, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 26348, .adv_w = 352, .box_w = 22, .box_h = 23, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 26601, .adv_w = 352, .box_w = 22, .box_h = 33, .ofs_x = 0, .ofs_y = -10}, + {.bitmap_index = 26964, .adv_w = 352, .box_w = 22, .box_h = 23, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 27217, .adv_w = 235, .box_w = 13, .box_h = 42, .ofs_x = 1, .ofs_y = -10}, + {.bitmap_index = 27490, .adv_w = 183, .box_w = 4, .box_h = 41, .ofs_x = 4, .ofs_y = -9}, + {.bitmap_index = 27572, .adv_w = 235, .box_w = 13, .box_h = 42, .ofs_x = 1, .ofs_y = -10}, + {.bitmap_index = 27845, .adv_w = 411, .box_w = 23, .box_h = 9, .ofs_x = 1, .ofs_y = 11}, + {.bitmap_index = 27949, .adv_w = 196, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 27949, .adv_w = 392, .box_w = 24, .box_h = 33, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 28345, .adv_w = 392, .box_w = 22, .box_h = 22, .ofs_x = 1, .ofs_y = 4}, + {.bitmap_index = 28587, .adv_w = 392, .box_w = 25, .box_h = 31, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 28975, .adv_w = 183, .box_w = 4, .box_h = 41, .ofs_x = 4, .ofs_y = -9}, + {.bitmap_index = 29057, .adv_w = 392, .box_w = 22, .box_h = 42, .ofs_x = 1, .ofs_y = -10}, + {.bitmap_index = 29519, .adv_w = 234, .box_w = 13, .box_h = 5, .ofs_x = 1, .ofs_y = 27}, + {.bitmap_index = 29552, .adv_w = 519, .box_w = 33, .box_h = 32, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 30080, .adv_w = 264, .box_w = 16, .box_h = 16, .ofs_x = 0, .ofs_y = 16}, + {.bitmap_index = 30208, .adv_w = 392, .box_w = 20, .box_h = 20, .ofs_x = 2, .ofs_y = 2}, + {.bitmap_index = 30408, .adv_w = 411, .box_w = 22, .box_h = 14, .ofs_x = 2, .ofs_y = 8}, + {.bitmap_index = 30562, .adv_w = 234, .box_w = 13, .box_h = 4, .ofs_x = 1, .ofs_y = 9}, + {.bitmap_index = 30588, .adv_w = 519, .box_w = 33, .box_h = 32, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 31116, .adv_w = 282, .box_w = 13, .box_h = 12, .ofs_x = 2, .ofs_y = 20}, + {.bitmap_index = 31194, .adv_w = 411, .box_w = 22, .box_h = 26, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 31480, .adv_w = 234, .box_w = 14, .box_h = 16, .ofs_x = 0, .ofs_y = 16}, + {.bitmap_index = 31592, .adv_w = 234, .box_w = 14, .box_h = 16, .ofs_x = 0, .ofs_y = 16}, + {.bitmap_index = 31704, .adv_w = 392, .box_w = 19, .box_h = 32, .ofs_x = 3, .ofs_y = -9}, + {.bitmap_index = 32008, .adv_w = 378, .box_w = 25, .box_h = 40, .ofs_x = -1, .ofs_y = -9}, + {.bitmap_index = 32508, .adv_w = 197, .box_w = 6, .box_h = 5, .ofs_x = 3, .ofs_y = 13}, + {.bitmap_index = 32523, .adv_w = 392, .box_w = 19, .box_h = 20, .ofs_x = 3, .ofs_y = 2}, + {.bitmap_index = 32713, .adv_w = 587, .box_w = 34, .box_h = 34, .ofs_x = 2, .ofs_y = -2}, + {.bitmap_index = 33291, .adv_w = 234, .box_w = 9, .box_h = 6, .ofs_x = 4, .ofs_y = 26}, + {.bitmap_index = 33318, .adv_w = 470, .box_w = 31, .box_h = 31, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 33799, .adv_w = 552, .box_w = 35, .box_h = 31, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 34342, .adv_w = 590, .box_w = 35, .box_h = 31, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 34885, .adv_w = 270, .box_w = 14, .box_h = 31, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 35102, .adv_w = 545, .box_w = 35, .box_h = 33, .ofs_x = -2, .ofs_y = -1}, + {.bitmap_index = 35680, .adv_w = 602, .box_w = 40, .box_h = 31, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 36300, .adv_w = 530, .box_w = 34, .box_h = 32, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 36844, .adv_w = 156, .box_w = 16, .box_h = 32, .ofs_x = -3, .ofs_y = 0}, + {.bitmap_index = 37100, .adv_w = 470, .box_w = 31, .box_h = 31, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 37581, .adv_w = 470, .box_w = 25, .box_h = 31, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 37969, .adv_w = 388, .box_w = 21, .box_h = 31, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 38295, .adv_w = 470, .box_w = 31, .box_h = 31, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 38776, .adv_w = 470, .box_w = 24, .box_h = 31, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 39148, .adv_w = 431, .box_w = 26, .box_h = 31, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 39551, .adv_w = 508, .box_w = 26, .box_h = 31, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 39954, .adv_w = 548, .box_w = 31, .box_h = 33, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 40466, .adv_w = 196, .box_w = 5, .box_h = 31, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 40544, .adv_w = 470, .box_w = 27, .box_h = 31, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 40963, .adv_w = 470, .box_w = 30, .box_h = 31, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 41428, .adv_w = 586, .box_w = 31, .box_h = 31, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 41909, .adv_w = 508, .box_w = 26, .box_h = 31, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 42312, .adv_w = 458, .box_w = 25, .box_h = 31, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 42700, .adv_w = 548, .box_w = 31, .box_h = 33, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 43212, .adv_w = 508, .box_w = 26, .box_h = 31, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 43615, .adv_w = 470, .box_w = 25, .box_h = 31, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 44003, .adv_w = 435, .box_w = 23, .box_h = 31, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 44360, .adv_w = 431, .box_w = 26, .box_h = 31, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 44763, .adv_w = 470, .box_w = 29, .box_h = 31, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 45213, .adv_w = 562, .box_w = 33, .box_h = 34, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 45774, .adv_w = 470, .box_w = 30, .box_h = 31, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 46239, .adv_w = 588, .box_w = 33, .box_h = 31, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 46751, .adv_w = 526, .box_w = 29, .box_h = 32, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 47215, .adv_w = 196, .box_w = 14, .box_h = 38, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 47481, .adv_w = 470, .box_w = 29, .box_h = 38, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 48032, .adv_w = 407, .box_w = 23, .box_h = 33, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 48412, .adv_w = 314, .box_w = 17, .box_h = 33, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 48693, .adv_w = 392, .box_w = 20, .box_h = 41, .ofs_x = 2, .ofs_y = -9}, + {.bitmap_index = 49103, .adv_w = 156, .box_w = 9, .box_h = 32, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 49247, .adv_w = 385, .box_w = 20, .box_h = 33, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 49577, .adv_w = 407, .box_w = 23, .box_h = 25, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 49865, .adv_w = 405, .box_w = 21, .box_h = 41, .ofs_x = 3, .ofs_y = -9}, + {.bitmap_index = 50296, .adv_w = 352, .box_w = 22, .box_h = 32, .ofs_x = 0, .ofs_y = -9}, + {.bitmap_index = 50648, .adv_w = 392, .box_w = 22, .box_h = 32, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 51000, .adv_w = 314, .box_w = 17, .box_h = 25, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 51213, .adv_w = 310, .box_w = 19, .box_h = 40, .ofs_x = 1, .ofs_y = -9}, + {.bitmap_index = 51593, .adv_w = 392, .box_w = 20, .box_h = 33, .ofs_x = 2, .ofs_y = -9}, + {.bitmap_index = 51923, .adv_w = 392, .box_w = 22, .box_h = 33, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 52286, .adv_w = 156, .box_w = 5, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 52344, .adv_w = 351, .box_w = 20, .box_h = 23, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 52574, .adv_w = 352, .box_w = 22, .box_h = 31, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 52915, .adv_w = 392, .box_w = 19, .box_h = 32, .ofs_x = 3, .ofs_y = -9}, + {.bitmap_index = 53219, .adv_w = 352, .box_w = 22, .box_h = 23, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 53472, .adv_w = 315, .box_w = 18, .box_h = 41, .ofs_x = 1, .ofs_y = -9}, + {.bitmap_index = 53841, .adv_w = 392, .box_w = 22, .box_h = 25, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 54116, .adv_w = 486, .box_w = 30, .box_h = 23, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 54461, .adv_w = 400, .box_w = 22, .box_h = 33, .ofs_x = 2, .ofs_y = -9}, + {.bitmap_index = 54824, .adv_w = 339, .box_w = 20, .box_h = 33, .ofs_x = 1, .ofs_y = -9}, + {.bitmap_index = 55154, .adv_w = 435, .box_w = 26, .box_h = 25, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 55479, .adv_w = 278, .box_w = 17, .box_h = 23, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 55675, .adv_w = 385, .box_w = 20, .box_h = 24, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 55915, .adv_w = 457, .box_w = 26, .box_h = 33, .ofs_x = 1, .ofs_y = -9}, + {.bitmap_index = 56344, .adv_w = 370, .box_w = 23, .box_h = 32, .ofs_x = 0, .ofs_y = -9}, + {.bitmap_index = 56712, .adv_w = 502, .box_w = 27, .box_h = 32, .ofs_x = 2, .ofs_y = -9}, + {.bitmap_index = 57144, .adv_w = 550, .box_w = 32, .box_h = 24, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 57528, .adv_w = 156, .box_w = 13, .box_h = 31, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 57730, .adv_w = 385, .box_w = 20, .box_h = 32, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 58050, .adv_w = 392, .box_w = 22, .box_h = 33, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 58413, .adv_w = 385, .box_w = 20, .box_h = 33, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 58743, .adv_w = 550, .box_w = 32, .box_h = 33, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 59271, .adv_w = 234, .box_w = 17, .box_h = 6, .ofs_x = -1, .ofs_y = 26} +}; + +/*--------------------- + * CHARACTER MAPPING + *--------------------*/ + +static const uint8_t glyph_id_ofs_list_1[] = { + 0, 0, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 0, + 13, 14, 15, 16, 0, 17, 18, 19, + 0, 0, 0, 20, 0, 21 +}; + +static const uint8_t glyph_id_ofs_list_2[] = { + 0, 0, 1, 0, 2, 3, 4, 0, + 5 +}; + +/*Collect the unicode lists and glyph_id offsets*/ +static const lv_font_fmt_txt_cmap_t cmaps[] = +{ + { + .range_start = 32, .range_length = 95, .glyph_id_start = 1, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 160, .range_length = 30, .glyph_id_start = 96, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_1, .list_length = 30, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 900, .range_length = 9, .glyph_id_start = 118, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_2, .list_length = 9, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 910, .range_length = 20, .glyph_id_start = 124, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 931, .range_length = 44, .glyph_id_start = 144, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 1012, .range_length = 1, .glyph_id_start = 188, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + } +}; + + + +/*-------------------- + * ALL CUSTOM DATA + *--------------------*/ + +#if LVGL_VERSION_MAJOR == 8 +/*Store all the custom data of the font*/ +static lv_font_fmt_txt_glyph_cache_t cache; +#endif + +#if LVGL_VERSION_MAJOR >= 8 +static const lv_font_fmt_txt_dsc_t font_dsc = { +#else +static lv_font_fmt_txt_dsc_t font_dsc = { +#endif + .glyph_bitmap = glyph_bitmap, + .glyph_dsc = glyph_dsc, + .cmaps = cmaps, + .kern_dsc = NULL, + .kern_scale = 0, + .cmap_num = 6, + .bpp = 4, + .kern_classes = 0, + .bitmap_format = 0, +#if LVGL_VERSION_MAJOR == 8 + .cache = &cache +#endif + +}; + +extern const lv_font_t lv_font_montserrat_44; + + +/*----------------- + * PUBLIC FONT + *----------------*/ + +/*Initialize a public general font descriptor*/ +#if LVGL_VERSION_MAJOR >= 8 +const lv_font_t lv_font_arial_44 = { +#else +lv_font_t lv_font_arial_44 = { +#endif + .get_glyph_dsc = lv_font_get_glyph_dsc_fmt_txt, /*Function pointer to get glyph's data*/ + .get_glyph_bitmap = lv_font_get_bitmap_fmt_txt, /*Function pointer to get glyph's bitmap*/ + .line_height = 48, /*The maximum line height required by the font*/ + .base_line = 10, /*Baseline measured from the bottom of the line*/ +#if !(LVGL_VERSION_MAJOR == 6 && LVGL_VERSION_MINOR == 0) + .subpx = LV_FONT_SUBPX_NONE, +#endif +#if LV_VERSION_CHECK(7, 4, 0) || LVGL_VERSION_MAJOR >= 8 + .underline_position = -5, + .underline_thickness = 3, +#endif + //.static_bitmap = 0, + .dsc = &font_dsc, /*The custom font data. Will be accessed by `get_glyph_bitmap/dsc` */ +#if LV_VERSION_CHECK(8, 2, 0) || LVGL_VERSION_MAJOR >= 9 + .fallback = &lv_font_montserrat_44, +#endif + .user_data = NULL, +}; + + + +#endif /*#if LV_FONT_ARIAL_44*/ diff --git a/src/fonts/lv_font_arial_48.c b/src/fonts/lv_font_arial_48.c new file mode 100644 index 0000000000..0a189c0996 --- /dev/null +++ b/src/fonts/lv_font_arial_48.c @@ -0,0 +1,9797 @@ +/******************************************************************************* + * Size: 48 px + * Bpp: 4 + * Opts: --bpp 4 --size 48 --no-compress --stride 1 --align 1 --font Arial Greek Regular.ttf --range 32-127,160-255,880-1023 --format lvgl -o lv_font_arial_48.c + ******************************************************************************/ + +#ifdef __has_include + #if __has_include("lvgl.h") + #ifndef LV_LVGL_H_INCLUDE_SIMPLE + #define LV_LVGL_H_INCLUDE_SIMPLE + #endif + #endif +#endif + +#ifdef LV_LVGL_H_INCLUDE_SIMPLE + #include "lvgl.h" +#else + #include "lvgl/lvgl.h" +#endif + + + +#ifndef LV_FONT_ARIAL_48 +#define LV_FONT_ARIAL_48 1 +#endif + +#if LV_FONT_ARIAL_48 + +/*----------------- + * BITMAPS + *----------------*/ + +/*Store the image of the glyphs*/ +static LV_ATTRIBUTE_LARGE_CONST const uint8_t glyph_bitmap[] = { + /* U+0020 " " */ + + /* U+0021 "!" */ + 0xff, 0xff, 0xf4, 0xff, 0xff, 0xf4, 0xff, 0xff, + 0xf4, 0xff, 0xff, 0xf4, 0xff, 0xff, 0xf4, 0xff, + 0xff, 0xf4, 0xff, 0xff, 0xf4, 0xef, 0xff, 0xf4, + 0xef, 0xff, 0xf3, 0xdf, 0xff, 0xf2, 0xcf, 0xff, + 0xf1, 0xaf, 0xff, 0xf0, 0x9f, 0xff, 0xf0, 0x8f, + 0xff, 0xe0, 0x7f, 0xff, 0xd0, 0x6f, 0xff, 0xc0, + 0x5f, 0xff, 0xb0, 0x4f, 0xff, 0xa0, 0x3f, 0xff, + 0x90, 0x2f, 0xff, 0x80, 0x1f, 0xff, 0x70, 0xf, + 0xff, 0x60, 0xe, 0xff, 0x50, 0xd, 0xff, 0x30, + 0xc, 0xff, 0x20, 0xb, 0xff, 0x10, 0x4, 0x66, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xae, 0xee, 0xe1, 0xcf, 0xff, 0xf1, + 0xcf, 0xff, 0xf1, 0xcf, 0xff, 0xf1, 0xcf, 0xff, + 0xf1, + + /* U+0022 "\"" */ + 0xcf, 0xff, 0xf0, 0x0, 0xff, 0xff, 0xdc, 0xff, + 0xff, 0x0, 0xf, 0xff, 0xfd, 0xcf, 0xff, 0xf0, + 0x0, 0xff, 0xff, 0xdc, 0xff, 0xff, 0x0, 0xf, + 0xff, 0xfd, 0xcf, 0xff, 0xf0, 0x0, 0xff, 0xff, + 0xdc, 0xff, 0xff, 0x0, 0xf, 0xff, 0xfc, 0xaf, + 0xff, 0xe0, 0x0, 0xdf, 0xff, 0xa7, 0xff, 0xfc, + 0x0, 0xb, 0xff, 0xf8, 0x4f, 0xff, 0x90, 0x0, + 0x8f, 0xff, 0x51, 0xff, 0xf7, 0x0, 0x5, 0xff, + 0xf2, 0xe, 0xff, 0x40, 0x0, 0x2f, 0xff, 0x0, + 0xcf, 0xf2, 0x0, 0x0, 0xff, 0xd0, 0x4, 0x66, + 0x0, 0x0, 0x5, 0x64, 0x0, + + /* U+0023 "#" */ + 0x0, 0x0, 0x0, 0x0, 0x2, 0x77, 0x71, 0x0, + 0x0, 0x0, 0x27, 0x77, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x10, 0x0, 0x0, 0x8, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0xcf, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfa, 0x0, + 0x0, 0x0, 0xf, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0x70, 0x0, 0x0, 0x2, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x10, + 0x0, 0x0, 0x8, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0xbf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xfb, 0x0, 0x0, 0x0, 0xe, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x70, + 0x0, 0x0, 0x1, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x30, 0x0, 0x6, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf3, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x36, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf3, 0x39, 0x99, 0x99, + 0x9f, 0xff, 0xc9, 0x99, 0x99, 0x9a, 0xff, 0xfb, + 0x99, 0x99, 0x10, 0x0, 0x0, 0x3, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x10, 0x0, 0x0, + 0x7, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xe0, 0x0, 0x0, 0x0, 0xbf, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfb, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x80, 0x0, 0x0, + 0x1, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x20, 0x0, 0x0, 0x7, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0xbf, 0xfd, 0x0, 0x0, 0x0, 0x3, 0x99, + 0x99, 0xef, 0xfe, 0x99, 0x99, 0x99, 0x9e, 0xff, + 0xe9, 0x99, 0x99, 0x91, 0x6f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x36, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x6f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, 0x8, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0xaf, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfc, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0x80, 0x0, 0x0, 0x1, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x20, 0x0, + 0x0, 0x7, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf0, 0x0, 0x0, 0x0, 0xaf, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xfb, 0x0, 0x0, 0x0, 0xe, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x80, 0x0, + 0x0, 0x1, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0x20, 0x0, 0x0, 0x7, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x11, 0x10, 0x0, + 0x0, 0x0, 0x1, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+0024 "$" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0x84, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0x5f, 0xfb, 0x41, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3a, + 0xff, 0xff, 0xff, 0xff, 0xc6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd3, 0x0, 0x0, 0x0, 0x1, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xf9, 0x4f, 0xfa, 0x7e, + 0xff, 0xff, 0xe1, 0x0, 0x0, 0x4f, 0xff, 0xfc, + 0x10, 0xf, 0xf8, 0x0, 0xaf, 0xff, 0xf9, 0x0, + 0x0, 0xbf, 0xff, 0xd0, 0x0, 0xf, 0xf8, 0x0, + 0xd, 0xff, 0xff, 0x0, 0x1, 0xff, 0xff, 0x40, + 0x0, 0xf, 0xf8, 0x0, 0x4, 0xff, 0xff, 0x50, + 0x4, 0xff, 0xff, 0x0, 0x0, 0xf, 0xf8, 0x0, + 0x0, 0xef, 0xff, 0x80, 0x6, 0xff, 0xfc, 0x0, + 0x0, 0xf, 0xf8, 0x0, 0x0, 0xab, 0x86, 0x20, + 0x7, 0xff, 0xfc, 0x0, 0x0, 0xf, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfe, 0x0, + 0x0, 0xf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0x40, 0x0, 0xf, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xd0, + 0x0, 0xf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xfc, 0x10, 0xf, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, + 0xf8, 0x1f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x71, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x91, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x7d, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xf8, 0x39, 0xff, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xf8, 0x0, + 0x2c, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xf8, 0x0, 0x0, 0xdf, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xf8, 0x0, + 0x0, 0x5f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xf8, 0x0, 0x0, 0xf, 0xff, 0xf6, + 0x0, 0x36, 0x91, 0x0, 0x0, 0xf, 0xf8, 0x0, + 0x0, 0xd, 0xff, 0xf8, 0x1f, 0xff, 0xf4, 0x0, + 0x0, 0xf, 0xf8, 0x0, 0x0, 0xd, 0xff, 0xf7, + 0xf, 0xff, 0xf8, 0x0, 0x0, 0xf, 0xf8, 0x0, + 0x0, 0xe, 0xff, 0xf6, 0xd, 0xff, 0xfd, 0x0, + 0x0, 0xf, 0xf8, 0x0, 0x0, 0x2f, 0xff, 0xf4, + 0x8, 0xff, 0xff, 0x40, 0x0, 0xf, 0xf8, 0x0, + 0x0, 0x8f, 0xff, 0xf0, 0x3, 0xff, 0xff, 0xd0, + 0x0, 0xf, 0xf8, 0x0, 0x3, 0xff, 0xff, 0x90, + 0x0, 0xbf, 0xff, 0xfb, 0x0, 0xf, 0xf8, 0x0, + 0x4f, 0xff, 0xff, 0x20, 0x0, 0x2f, 0xff, 0xff, + 0xd6, 0x2f, 0xf9, 0x4a, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x3d, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6d, 0xff, 0xff, 0xff, 0xff, + 0xfb, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x25, 0x8f, 0xfc, 0x64, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0025 "%" */ + 0x0, 0x0, 0x0, 0x57, 0x75, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0x88, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xfa, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xe9, 0x8b, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfd, 0x10, + 0x0, 0x6f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xf4, 0x0, 0x0, 0xc, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xe0, 0x0, 0x0, 0x6, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xb0, + 0x0, 0x0, 0x3, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xa0, 0x0, 0x0, 0x2, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0xe, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x90, 0x0, 0x0, + 0x1, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x7f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0x90, 0x0, 0x0, 0x2, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0xef, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xa0, 0x0, 0x0, 0x3, 0xff, + 0xf7, 0x0, 0x0, 0x7, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xc0, 0x0, + 0x0, 0x5, 0xff, 0xf5, 0x0, 0x0, 0xe, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xf0, 0x0, 0x0, 0xa, 0xff, 0xf1, 0x0, + 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xf7, 0x0, 0x0, 0x2f, + 0xff, 0xb0, 0x0, 0x0, 0xef, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x71, 0x3, 0xdf, 0xff, 0x30, 0x0, 0x7, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0xe, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xef, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xcf, 0xfd, 0x92, 0x0, 0x0, 0x0, 0xef, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xe0, 0x0, 0x0, 0x6, 0xbe, + 0xfe, 0xa4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0x70, 0x0, + 0x1, 0xcf, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xfe, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xf7, 0x0, 0x0, 0x8f, 0xff, + 0xb2, 0x2, 0xbf, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xe0, 0x0, + 0x0, 0xff, 0xfc, 0x0, 0x0, 0xd, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0x70, 0x0, 0x5, 0xff, 0xf5, 0x0, 0x0, + 0x6, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x9, 0xff, + 0xf1, 0x0, 0x0, 0x1, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf7, 0x0, + 0x0, 0xc, 0xff, 0xe0, 0x0, 0x0, 0x0, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xe0, 0x0, 0x0, 0xd, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0xef, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0x70, 0x0, 0x0, 0xd, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0xdf, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfe, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0xef, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0xb, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf0, 0x0, 0x0, 0x2, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf4, 0x0, 0x0, + 0x7, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xfc, 0x0, 0x0, 0xe, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xa2, 0x3, 0xcf, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xbe, 0xfd, 0x93, + 0x0, 0x0, + + /* U+0026 "&" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x26, 0x77, 0x51, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xdf, 0xff, 0xff, 0xfb, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xb3, + 0x12, 0x8f, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x4f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x10, + 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf9, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xf5, 0x0, 0x0, 0xcf, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xf3, 0x1, 0xcf, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xe7, 0xef, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xff, 0xc2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2a, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xcf, + 0xff, 0xff, 0xef, 0xff, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xfe, + 0x51, 0xef, 0xff, 0xfc, 0x0, 0x0, 0x5, 0x30, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfc, 0x10, 0x3, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0xff, 0xfc, 0x50, + 0x0, 0x8f, 0xff, 0xfc, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xf5, 0x0, 0x5f, 0xff, 0xf4, 0x0, 0x1f, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf2, 0xa, 0xff, 0xff, 0x0, 0x7, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xd2, + 0xff, 0xff, 0xa0, 0x0, 0xbf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xef, 0xff, + 0xf5, 0x0, 0xe, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0xef, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0x60, 0x0, 0xd, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xc0, 0x0, 0x0, 0xaf, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xfe, 0x10, 0x0, 0x5, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0xe, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x4, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xd7, 0x55, 0x7c, 0xff, + 0xff, 0xfe, 0x28, 0xff, 0xff, 0xfc, 0x10, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x20, 0xa, 0xff, 0xff, 0xfa, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x10, 0x0, + 0xa, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x3b, 0xff, + 0xff, 0xff, 0xff, 0xa3, 0x0, 0x0, 0x0, 0x8, + 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, 0x46, 0x77, + 0x63, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x40, + 0x0, + + /* U+0027 "'" */ + 0xdf, 0xff, 0xfd, 0xff, 0xff, 0xdf, 0xff, 0xfd, + 0xff, 0xff, 0xdf, 0xff, 0xfc, 0xff, 0xff, 0xbf, + 0xff, 0xd8, 0xff, 0xfb, 0x6f, 0xff, 0x83, 0xff, + 0xf5, 0xf, 0xff, 0x30, 0xef, 0xf0, 0x5, 0x66, + 0x0, + + /* U+0028 "(" */ + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x40, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x60, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x80, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xe0, + + /* U+0029 ")" */ + 0x1e, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x60, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x90, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x40, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x20, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x80, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf2, 0x0, + 0x0, 0x0, 0x0, + + /* U+002A "*" */ + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x11, 0x0, 0x2, 0xff, 0xc0, 0x0, + 0x2, 0x0, 0x9, 0xfa, 0x40, 0xf, 0xfa, 0x0, + 0x6c, 0xf4, 0x0, 0xef, 0xff, 0xd5, 0xff, 0xa8, + 0xff, 0xff, 0x90, 0x3f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x0, 0x48, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xc8, 0x30, 0x0, 0x0, 0x3, 0xef, + 0xff, 0xb2, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xfd, 0x5f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x50, 0xcf, 0xff, 0x20, 0x0, 0x0, 0x3f, + 0xff, 0xc0, 0x2, 0xff, 0xfd, 0x10, 0x0, 0x1, + 0xaf, 0xf3, 0x0, 0x8, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x68, 0x0, 0x0, 0xb, 0x30, 0x0, 0x0, + + /* U+002B "+" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x33, 0x33, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf5, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf5, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+002C "," */ + 0xc, 0xee, 0xee, 0xd, 0xff, 0xff, 0xd, 0xff, + 0xff, 0xd, 0xff, 0xff, 0xd, 0xff, 0xff, 0x0, + 0x7, 0xfe, 0x0, 0x9, 0xfd, 0x0, 0xd, 0xfa, + 0x0, 0x4f, 0xf5, 0x4, 0xef, 0xd0, 0xd, 0xfe, + 0x20, 0x3, 0xa1, 0x0, + + /* U+002D "-" */ + 0x25, 0x55, 0x55, 0x55, 0x55, 0x55, 0x52, 0x7f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf7, 0x7f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf7, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf7, + + /* U+002E "." */ + 0xae, 0xee, 0xe1, 0xbf, 0xff, 0xf1, 0xbf, 0xff, + 0xf1, 0xbf, 0xff, 0xf1, 0xbf, 0xff, 0xf1, + + /* U+002F "/" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x88, 0x82, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+0030 "0" */ + 0x0, 0x0, 0x0, 0x5, 0xad, 0xff, 0xec, 0x83, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5e, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x20, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xda, + 0x9b, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x2f, + 0xff, 0xfe, 0x50, 0x0, 0x1, 0x9f, 0xff, 0xfb, + 0x0, 0x0, 0xb, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf4, 0x0, 0x2, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xb0, + 0x0, 0x8f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0x10, 0xd, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf6, 0x1, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xa0, 0x4f, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xfe, 0x7, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf0, 0x9f, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0x3b, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf4, 0xcf, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0x6d, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf7, + 0xef, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x7e, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf7, 0xef, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x7d, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf7, 0xdf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0x6c, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf5, 0xaf, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0x48, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf2, 0x6f, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x3, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xc0, 0xf, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xf8, 0x0, 0xbf, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0x40, 0x5, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xe0, 0x0, 0xe, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf8, + 0x0, 0x0, 0x6f, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x2d, 0xff, 0xfe, 0x10, 0x0, 0x0, 0xcf, 0xff, + 0xfc, 0x52, 0x12, 0x8f, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x1, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6d, 0xff, 0xff, 0xff, 0xfb, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x57, + 0x76, 0x41, 0x0, 0x0, 0x0, 0x0, + + /* U+0031 "1" */ + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0x0, + 0x1, 0xaf, 0xff, 0xff, 0xff, 0xf0, 0x6, 0xef, + 0xff, 0xff, 0xff, 0xff, 0x4d, 0xff, 0xff, 0xfc, + 0x5f, 0xff, 0xfa, 0xff, 0xff, 0xf9, 0x3, 0xff, + 0xff, 0xaf, 0xff, 0xd4, 0x0, 0x3f, 0xff, 0xfa, + 0xfe, 0x70, 0x0, 0x3, 0xff, 0xff, 0x86, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xf0, + + /* U+0032 "2" */ + 0x0, 0x0, 0x0, 0x1, 0x7a, 0xde, 0xfe, 0xda, + 0x61, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x4e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x10, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xca, 0x9a, 0xef, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xa1, 0x0, 0x0, 0x4, + 0xdf, 0xff, 0xfa, 0x0, 0x0, 0x8f, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0x30, + 0x0, 0xef, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xa0, 0x4, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xe0, + 0x7, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf1, 0x9, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf2, + 0x1, 0x35, 0x65, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xfe, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1b, 0xff, 0xff, + 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xdf, 0xff, 0xfd, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, 0xff, 0xc1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xa2, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x22, 0x22, 0x20, 0xd, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf3, 0x6f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf3, + + /* U+0033 "3" */ + 0x0, 0x0, 0x0, 0x27, 0xbe, 0xff, 0xdb, 0x61, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x10, 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xb9, + 0x9b, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xf8, 0x0, 0x0, 0x1, 0xaf, 0xff, 0xf9, + 0x0, 0x0, 0x5f, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xf2, 0x0, 0xc, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x80, + 0x1, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xfc, 0x0, 0x5f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xd0, 0x0, + 0x36, 0x89, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3c, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x57, 0xcf, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xfe, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0xd8, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x33, 0x10, 0x15, 0xbf, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x94, + 0x79, 0xb5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xf8, 0xcf, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x69, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xf3, 0x4f, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xfe, 0x0, 0xdf, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0x70, 0x4, 0xff, 0xff, 0xd2, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xd0, 0x0, 0x9, 0xff, 0xff, + 0xf8, 0x31, 0x13, 0x7e, 0xff, 0xff, 0xe2, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe3, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb1, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xaf, 0xff, 0xff, 0xff, 0xfb, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x67, + 0x76, 0x40, 0x0, 0x0, 0x0, 0x0, + + /* U+0034 "4" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xaf, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0x96, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xe0, + 0x6f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf4, 0x6, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf9, + 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xfd, 0x0, 0x6, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x30, 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x90, 0x0, 0x6, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xd0, 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xf3, 0x0, 0x0, 0x6, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xd0, 0x0, 0x0, 0x1e, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xfd, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf7, 0x4f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x74, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf7, 0x4f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xfd, 0x0, 0x0, 0x0, + + /* U+0035 "5" */ + 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, 0xa, + 0xff, 0xf8, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x20, 0x0, 0x0, 0xdf, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0x0, 0x49, 0xdf, + 0xfe, 0xb7, 0x10, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xd4, 0xdf, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd2, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xff, 0xfd, 0xde, 0xff, 0xff, 0xff, 0xe2, 0x0, + 0xc, 0xff, 0xff, 0xfa, 0x30, 0x0, 0x2, 0x9f, + 0xff, 0xff, 0xd0, 0x0, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x3e, 0xff, 0xff, 0x70, 0x1b, + 0xdf, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xc2, + 0x45, 0x74, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xfa, 0xcf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x69, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xf2, 0x5f, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xfc, 0x0, 0xff, 0xff, + 0xe2, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0x40, 0x7, 0xff, 0xff, 0xd2, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xa0, 0x0, 0xc, 0xff, 0xff, + 0xf9, 0x31, 0x12, 0x7d, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x1c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe2, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb1, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xaf, 0xff, 0xff, 0xff, 0xfb, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x67, + 0x76, 0x41, 0x0, 0x0, 0x0, 0x0, + + /* U+0036 "6" */ + 0x0, 0x0, 0x0, 0x0, 0x6a, 0xdf, 0xfe, 0xc8, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb1, 0x0, 0x0, 0x0, + 0x0, 0x1c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe3, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xfb, + 0x99, 0xbf, 0xff, 0xff, 0xe2, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xa1, 0x0, 0x0, 0x19, 0xff, 0xff, + 0xb0, 0x0, 0x5, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0x40, 0x0, 0xdf, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfa, + 0x0, 0x4f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xd0, 0xa, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xdc, 0xb9, 0x0, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x80, 0x0, 0x5, 0x9b, + 0xcb, 0x94, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf6, + 0x0, 0x7e, 0xff, 0xff, 0xff, 0xfe, 0x60, 0x0, + 0x0, 0xdf, 0xff, 0x40, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0xe, 0xff, 0xf4, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0xff, 0xff, 0xcf, 0xff, 0xc6, 0x20, 0x14, 0x9f, + 0xff, 0xff, 0x90, 0xf, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0x30, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xfb, 0xf, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf1, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x5e, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf8, 0xdf, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x9b, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfa, 0x9f, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x96, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf8, 0x2f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x50, 0xdf, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf1, 0x7, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xfc, 0x0, 0x1f, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x50, 0x0, 0x7f, 0xff, 0xfb, 0x10, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xc0, 0x0, 0x0, 0xbf, 0xff, + 0xfe, 0x73, 0x11, 0x4a, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x19, 0xef, 0xff, 0xff, 0xfe, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x35, + 0x77, 0x53, 0x0, 0x0, 0x0, 0x0, + + /* U+0037 "7" */ + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x9a, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x9a, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x12, 0x22, + 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x4f, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+0038 "8" */ + 0x0, 0x0, 0x0, 0x6, 0xad, 0xff, 0xec, 0x84, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6e, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x30, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xd9, + 0x8a, 0xef, 0xff, 0xff, 0x60, 0x0, 0x0, 0x5f, + 0xff, 0xfd, 0x30, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0x10, 0x0, 0xe, 0xff, 0xfd, 0x10, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf9, 0x0, 0x3, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xe0, + 0x0, 0x7f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0x20, 0x8, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf3, 0x0, + 0x8f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0x30, 0x6, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf1, 0x0, 0x3f, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xfc, 0x0, 0x0, 0xcf, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0x50, 0x0, 0x2, 0xff, + 0xff, 0xfa, 0x41, 0x1, 0x5d, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x3, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x1, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x29, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x40, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xb9, 0x8a, 0xef, 0xff, 0xff, 0x90, 0x0, 0x0, + 0xaf, 0xff, 0xf9, 0x10, 0x0, 0x0, 0x4d, 0xff, + 0xff, 0x90, 0x0, 0x6f, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0x40, 0xe, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, + 0xfc, 0x6, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xf2, 0xaf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0x7d, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf9, 0xef, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xae, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf9, 0xcf, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x8a, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xf5, 0x5f, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0x10, 0xef, 0xff, + 0xe2, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xa0, 0x6, 0xff, 0xff, 0xe3, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xf2, 0x0, 0xa, 0xff, 0xff, + 0xfa, 0x41, 0x2, 0x5b, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe3, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x8e, 0xff, 0xff, 0xff, 0xfd, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x56, + 0x76, 0x51, 0x0, 0x0, 0x0, 0x0, + + /* U+0039 "9" */ + 0x0, 0x0, 0x0, 0x27, 0xbd, 0xff, 0xda, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xe6, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x10, 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xda, + 0x9a, 0xef, 0xff, 0xfd, 0x10, 0x0, 0x0, 0xcf, + 0xff, 0xfd, 0x40, 0x0, 0x0, 0x6f, 0xff, 0xfc, + 0x0, 0x0, 0x6f, 0xff, 0xfc, 0x10, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xf7, 0x0, 0xe, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xe0, + 0x4, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x60, 0x8f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfb, 0xb, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf0, 0xdf, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x2e, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf5, 0xdf, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0x7c, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf8, 0x9f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x95, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfa, + 0x1f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xa0, 0x9f, 0xff, 0xfb, 0x10, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfa, 0x1, + 0xef, 0xff, 0xfe, 0x60, 0x0, 0x2, 0x9f, 0xff, + 0xdf, 0xff, 0xa0, 0x4, 0xff, 0xff, 0xff, 0xfd, + 0xde, 0xff, 0xff, 0xa8, 0xff, 0xf9, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x9f, + 0xff, 0x80, 0x0, 0x2, 0xbf, 0xff, 0xff, 0xff, + 0xfe, 0x60, 0xa, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x49, 0xde, 0xfe, 0xb6, 0x0, 0x0, 0xcf, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xd0, 0x4, 0x57, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xf8, 0x2, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0x30, 0xf, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xd0, 0x0, 0xaf, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf5, + 0x0, 0x3, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xfb, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xc5, 0x10, 0x25, 0xcf, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x1d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x20, 0x0, 0x0, 0x0, 0x1b, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xcf, 0xff, 0xff, 0xff, 0xc5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x15, 0x67, + 0x75, 0x10, 0x0, 0x0, 0x0, 0x0, + + /* U+003A ":" */ + 0xbf, 0xff, 0xf1, 0xbf, 0xff, 0xf1, 0xbf, 0xff, + 0xf1, 0xbf, 0xff, 0xf1, 0xae, 0xee, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xae, 0xee, 0xe1, 0xbf, + 0xff, 0xf1, 0xbf, 0xff, 0xf1, 0xbf, 0xff, 0xf1, + 0xbf, 0xff, 0xf1, + + /* U+003B ";" */ + 0xd, 0xff, 0xff, 0xd, 0xff, 0xff, 0xd, 0xff, + 0xff, 0xd, 0xff, 0xff, 0xc, 0xee, 0xee, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xee, 0xee, 0xd, + 0xff, 0xff, 0xd, 0xff, 0xff, 0xd, 0xff, 0xff, + 0xd, 0xff, 0xff, 0x0, 0x7, 0xfe, 0x0, 0x9, + 0xfd, 0x0, 0xd, 0xfa, 0x0, 0x4f, 0xf5, 0x4, + 0xef, 0xd0, 0xd, 0xfe, 0x20, 0x3, 0xa1, 0x0, + + /* U+003C "<" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xc6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x18, 0xef, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3a, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5c, + 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x7e, 0xff, 0xff, 0xff, 0xfe, 0x71, + 0x0, 0x0, 0x0, 0x0, 0x3, 0x9f, 0xff, 0xff, + 0xff, 0xfb, 0x50, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xcf, 0xff, 0xff, 0xff, 0xf9, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x17, 0xef, 0xff, 0xff, 0xff, 0xd6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x29, 0xff, 0xff, + 0xff, 0xff, 0xa4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2b, 0xff, 0xff, 0xff, 0xfe, 0x81, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xfc, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xd6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xff, 0xf9, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x7e, 0xff, 0xff, + 0xff, 0xfb, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5c, 0xff, 0xff, 0xff, 0xfe, 0x71, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3a, + 0xff, 0xff, 0xff, 0xff, 0x93, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x18, 0xef, 0xff, 0xff, + 0xff, 0xc5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xdf, 0xff, 0xff, 0xff, 0xe8, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xbf, + 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0x9f, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x7e, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5c, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x33, + + /* U+003D "=" */ + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf5, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf5, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf5, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf5, + + /* U+003E ">" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5d, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xfe, 0x81, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xa3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xc5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xdf, 0xff, 0xff, + 0xff, 0xe8, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xbf, 0xff, 0xff, 0xff, 0xfa, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x8e, + 0xff, 0xff, 0xff, 0xfc, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6d, 0xff, 0xff, 0xff, + 0xfe, 0x71, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3a, 0xff, 0xff, 0xff, 0xff, 0xa3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x17, 0xef, + 0xff, 0xff, 0xff, 0xc2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xcf, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xcf, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6d, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x8f, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xbf, 0xff, 0xff, 0xff, 0xe7, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x17, 0xdf, 0xff, 0xff, + 0xff, 0xc5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x29, + 0xff, 0xff, 0xff, 0xff, 0xa3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5c, 0xff, 0xff, 0xff, 0xfe, 0x81, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x7e, 0xff, 0xff, + 0xff, 0xfd, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xff, 0xfb, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf9, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xe7, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xc5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x23, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+003F "?" */ + 0x0, 0x0, 0x0, 0x0, 0x25, 0x67, 0x65, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x29, 0xef, + 0xff, 0xff, 0xff, 0xd7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x50, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xa4, 0x11, 0x26, 0xcf, 0xff, 0xff, + 0x70, 0x0, 0x3f, 0xff, 0xfe, 0x40, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0x20, 0xb, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfa, + 0x1, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xf0, 0x6f, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x39, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf5, 0x7b, 0xdf, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xdf, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xef, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x56, 0x66, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xee, 0xee, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + + /* U+0040 "@" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0x46, 0x77, 0x77, 0x53, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x8c, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xa5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xdf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xfe, 0xa6, 0x31, 0x0, + 0x1, 0x35, 0x8d, 0xff, 0xff, 0xff, 0xb1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1d, + 0xff, 0xff, 0xfa, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x28, 0xff, 0xff, 0xfd, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xfc, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x19, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4e, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xe3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xef, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2e, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x67, 0x74, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x6, 0xdf, 0xff, + 0xff, 0xf9, 0x0, 0x6, 0xff, 0xfc, 0x0, 0x0, + 0x8f, 0xff, 0x60, 0x0, 0x0, 0x4, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x1, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xd1, 0x9, 0xff, 0xf9, 0x0, 0x0, 0xe, + 0xff, 0xc0, 0x0, 0x0, 0xc, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0xd, 0xff, 0xf5, 0x0, 0x0, 0x8, 0xff, + 0xf2, 0x0, 0x0, 0x3f, 0xff, 0x70, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xfc, 0x52, 0x14, 0xaf, 0xff, + 0xaf, 0xff, 0xf2, 0x0, 0x0, 0x2, 0xff, 0xf6, + 0x0, 0x0, 0x9f, 0xff, 0x10, 0x0, 0x0, 0xc, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0xef, 0xfa, 0x0, + 0x0, 0xef, 0xf9, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0xbf, 0xfc, 0x0, 0x4, + 0xff, 0xf4, 0x0, 0x0, 0x2, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x9f, 0xfe, 0x0, 0x8, 0xff, + 0xf0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x0, 0xb, 0xff, 0xb0, + 0x0, 0x0, 0x2f, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0x0, 0xe, 0xff, 0x80, 0x0, + 0x0, 0x8f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xfe, 0x0, 0xf, 0xff, 0x60, 0x0, 0x0, + 0xcf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xfc, 0x0, 0x2f, 0xff, 0x40, 0x0, 0x0, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfa, + 0x0, 0x3f, 0xff, 0x30, 0x0, 0x2, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf6, 0x0, + 0x4f, 0xff, 0x30, 0x0, 0x4, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf1, 0x0, 0x4f, + 0xff, 0x30, 0x0, 0x5, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xc0, 0x0, 0x3f, 0xff, + 0x40, 0x0, 0x4, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0x50, 0x0, 0x2f, 0xff, 0x50, + 0x0, 0x3, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x50, 0x0, 0x0, 0x4, + 0xff, 0xfc, 0x0, 0x0, 0xf, 0xff, 0x80, 0x0, + 0x0, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0x20, 0x0, 0x0, 0x1e, 0xff, + 0xf3, 0x0, 0x0, 0xe, 0xff, 0xb0, 0x0, 0x0, + 0xcf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0x0, 0x0, 0x1, 0xdf, 0xff, 0x80, + 0x0, 0x0, 0xb, 0xff, 0xf0, 0x0, 0x0, 0x5f, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x4e, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf4, 0x0, 0x0, 0xd, 0xff, + 0xff, 0x60, 0x0, 0x2, 0xcf, 0xff, 0xff, 0xff, + 0x50, 0x3a, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xfa, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xfd, 0x99, 0xcf, 0xff, 0xca, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x20, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x16, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x90, 0x0, 0x0, 0x5, 0xef, 0xff, 0xff, + 0xff, 0x80, 0x0, 0xdf, 0xff, 0xff, 0xff, 0xe5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x17, 0xce, 0xfd, 0x82, + 0x0, 0x0, 0x19, 0xdf, 0xfd, 0xa5, 0x0, 0x0, + 0x0, 0x28, 0x88, 0x70, 0x0, 0x5, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x80, 0x0, 0x0, 0xbf, 0xff, 0xc1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xfc, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xcf, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xe5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4e, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xc4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2b, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xef, 0xff, 0xff, 0xd7, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4b, + 0xff, 0xff, 0xfd, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1a, 0xff, 0xff, 0xff, 0xfe, 0xa7, + 0x52, 0x11, 0x1, 0x23, 0x57, 0xbf, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4d, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5b, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xc5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x15, 0xad, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xeb, 0x61, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0x46, 0x77, 0x77, 0x65, + 0x31, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+0041 "A" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x8f, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x1e, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xfd, 0x9, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf8, 0x3, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf3, + 0x0, 0xdf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xe0, 0x0, 0x7f, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x80, 0x0, 0x2f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0x20, 0x0, 0xc, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xfc, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf6, 0x0, 0x0, 0x0, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xfc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xef, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0x80, 0x0, 0x0, 0xe, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x5f, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf5, 0x0, 0x0, + 0xbf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xfb, 0x0, + 0x1, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0x20, 0x7, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x80, 0xd, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xe0, + + /* U+0042 "B" */ + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xed, + 0xb8, 0x40, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x10, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x7f, 0xff, + 0xf3, 0x22, 0x22, 0x22, 0x23, 0x46, 0x9d, 0xff, + 0xff, 0xf9, 0x0, 0x7, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf2, + 0x0, 0x7f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0x70, 0x7, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xfa, 0x0, 0x7f, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xc0, 0x7, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfc, 0x0, 0x7f, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xb0, 0x7, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xf7, 0x0, 0x7f, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x10, 0x7, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0x80, 0x0, 0x7f, 0xff, 0xf3, + 0x22, 0x22, 0x22, 0x22, 0x35, 0x8d, 0xff, 0xff, + 0xb0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe6, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x7, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x1, + 0x24, 0x8d, 0xff, 0xff, 0xf9, 0x0, 0x7f, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xf5, 0x7, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xc0, 0x7f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x27, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xf5, 0x7f, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0x77, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf6, 0x7f, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0x57, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf2, 0x7f, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfe, 0x7, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0x70, 0x7f, 0xff, 0xf3, + 0x22, 0x22, 0x22, 0x22, 0x23, 0x59, 0xef, 0xff, + 0xff, 0xd0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe3, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x91, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xdb, 0x85, 0x0, 0x0, 0x0, + 0x0, + + /* U+0043 "C" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x57, + 0x77, 0x54, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x16, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xc6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xfe, 0xa9, 0x88, 0xad, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0x83, 0x0, 0x0, 0x0, 0x3, + 0xbf, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xfc, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x60, 0x0, 0x0, 0xcf, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xfe, 0x0, 0x0, 0x6f, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf7, 0x0, 0xd, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xd0, 0x4, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xfd, 0x10, 0x9f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x49, + 0x51, 0x0, 0xe, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0x0, 0x0, 0xb, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xc7, 0x30, 0x7f, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xfa, 0x1, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0x50, 0xb, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xf0, 0x0, 0x4f, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xf8, 0x0, 0x0, 0xaf, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0x10, 0x0, 0x1, 0xff, 0xff, 0xfc, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0x81, 0x0, + 0x0, 0x0, 0x5, 0xdf, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xfc, 0xa8, + 0x78, 0xbf, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x39, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xb5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x14, 0x67, 0x77, 0x53, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0044 "D" */ + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0xda, 0x84, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe8, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe3, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x3f, 0xff, 0xf6, 0x22, + 0x22, 0x22, 0x22, 0x34, 0x7a, 0xef, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x3f, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xef, 0xff, 0xfe, + 0x10, 0x0, 0x3f, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, 0xa0, + 0x0, 0x3f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf2, 0x0, + 0x3f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf9, 0x0, 0x3f, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0x0, 0x3f, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0x40, 0x3f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0x90, 0x3f, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xc0, 0x3f, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xe0, 0x3f, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xf0, 0x3f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf1, + 0x3f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf2, 0x3f, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf2, 0x3f, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xf2, 0x3f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xf1, 0x3f, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf0, 0x3f, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xd0, 0x3f, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xb0, 0x3f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x70, + 0x3f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x30, 0x3f, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xfe, 0x0, 0x3f, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xf7, 0x0, 0x3f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xf1, 0x0, 0x3f, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, + 0xff, 0x70, 0x0, 0x3f, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x3f, 0xff, 0xf6, 0x22, 0x22, 0x22, + 0x22, 0x35, 0x7a, 0xff, 0xff, 0xff, 0xe2, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0x30, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd2, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc5, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xc9, 0x62, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0045 "E" */ + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x3, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xa0, 0x3f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x3f, 0xff, + 0xf6, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x22, 0x21, 0x3, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf6, + 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, + 0x11, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x50, 0x3, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf5, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, + 0x3, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf6, + 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x22, 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x73, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf7, 0x3f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x70, + + /* U+0046 "F" */ + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x2, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf0, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x2, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf0, 0x2f, 0xff, 0xf7, 0x22, 0x22, 0x22, + 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x2, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xf7, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x21, 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf8, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x2, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0047 "G" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x46, + 0x77, 0x76, 0x41, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x9e, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x94, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4c, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xff, + 0xff, 0xca, 0x98, 0x89, 0xcf, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xff, + 0xd6, 0x10, 0x0, 0x0, 0x0, 0x6, 0xdf, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xf8, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xf0, 0x0, 0x9, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x50, 0x0, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf9, 0x0, 0x6f, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6a, 0x62, 0x0, 0xb, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x47, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf4, 0x7f, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x45, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf4, 0x3f, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x22, 0x22, 0x22, 0x22, + 0x24, 0xff, 0xff, 0x40, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xf4, 0xc, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x40, 0x7f, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf4, 0x1, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x40, 0xa, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf4, 0x0, 0x2f, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x40, 0x0, + 0x7f, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xef, 0xff, 0xf4, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xb2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4c, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xfa, 0x51, 0x0, + 0x0, 0x0, 0x27, 0xdf, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xfd, + 0xcb, 0xbc, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2a, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x8c, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xb6, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x35, 0x77, 0x76, 0x53, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+0048 "H" */ + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x2f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x2f, 0xff, 0xf7, 0x22, + 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x2c, + 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfc, + + /* U+0049 "I" */ + 0x9f, 0xff, 0xf9, 0xff, 0xff, 0x9f, 0xff, 0xf9, + 0xff, 0xff, 0x9f, 0xff, 0xf9, 0xff, 0xff, 0x9f, + 0xff, 0xf9, 0xff, 0xff, 0x9f, 0xff, 0xf9, 0xff, + 0xff, 0x9f, 0xff, 0xf9, 0xff, 0xff, 0x9f, 0xff, + 0xf9, 0xff, 0xff, 0x9f, 0xff, 0xf9, 0xff, 0xff, + 0x9f, 0xff, 0xf9, 0xff, 0xff, 0x9f, 0xff, 0xf9, + 0xff, 0xff, 0x9f, 0xff, 0xf9, 0xff, 0xff, 0x9f, + 0xff, 0xf9, 0xff, 0xff, 0x9f, 0xff, 0xf9, 0xff, + 0xff, 0x9f, 0xff, 0xf9, 0xff, 0xff, 0x9f, 0xff, + 0xf9, 0xff, 0xff, 0x9f, 0xff, 0xf9, 0xff, 0xff, + 0x9f, 0xff, 0xf9, 0xff, 0xff, 0x9f, 0xff, 0xf0, + + /* U+004A "J" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf4, + 0x2, 0x57, 0x40, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf4, 0x9f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf3, 0x8f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf2, 0x7f, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf0, + 0x4f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xd0, 0x1f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0x90, 0xb, 0xff, 0xff, 0xb1, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0x30, 0x3, 0xff, + 0xff, 0xff, 0xca, 0xbe, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe2, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x20, 0x0, 0x0, 0x0, 0x4c, 0xff, + 0xff, 0xff, 0xfd, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x15, 0x67, 0x65, 0x10, 0x0, 0x0, 0x0, + + /* U+004B "K" */ + 0x7f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xfc, 0x7, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xfb, 0x0, 0x7f, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xfb, 0x0, 0x7, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x7f, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x7, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xf1, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0x10, 0x0, 0x3, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xf1, 0x0, 0x3, 0xef, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x10, + 0x2, 0xef, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf1, 0x2, 0xef, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x12, 0xef, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xf3, 0xef, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xef, 0xff, 0xf9, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xff, 0xf7, 0x7, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0xb, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0x80, 0x0, 0x0, 0x7f, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x40, 0x0, 0x7, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xfe, 0x10, 0x0, 0x7f, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xfb, + 0x0, 0x7, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf6, 0x0, + 0x7f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf2, 0x7, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xd0, 0x7f, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x90, + + /* U+004C "L" */ + 0x6f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xf4, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x22, 0x22, 0x22, 0x6, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x16, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0x6f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x10, + + /* U+004D "M" */ + 0x6f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xf6, 0x6f, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xf6, 0x6f, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xf6, 0x6f, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xf6, 0x6f, 0xff, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xf6, 0x6f, 0xff, 0xfe, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xf6, 0x6f, 0xff, + 0xf9, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xbf, 0xff, 0xf6, 0x6f, + 0xff, 0xf3, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x6f, 0xff, 0xf6, + 0x6f, 0xff, 0xf0, 0xef, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x1f, 0xff, + 0xf6, 0x6f, 0xff, 0xf0, 0x9f, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfb, 0xf, + 0xff, 0xf6, 0x6f, 0xff, 0xf0, 0x3f, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf6, + 0xf, 0xff, 0xf6, 0x6f, 0xff, 0xf0, 0xe, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf1, 0xf, 0xff, 0xf6, 0x6f, 0xff, 0xf0, 0x9, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xb0, 0xf, 0xff, 0xf6, 0x6f, 0xff, 0xf0, + 0x3, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x50, 0xf, 0xff, 0xf6, 0x6f, 0xff, + 0xf0, 0x0, 0xef, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0x0, 0xf, 0xff, 0xf6, 0x6f, + 0xff, 0xf0, 0x0, 0x9f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xfa, 0x0, 0xf, 0xff, 0xf6, + 0x6f, 0xff, 0xf0, 0x0, 0x3f, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xf5, 0x0, 0xf, 0xff, + 0xf6, 0x6f, 0xff, 0xf0, 0x0, 0xe, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf0, 0x0, 0xf, + 0xff, 0xf6, 0x6f, 0xff, 0xf0, 0x0, 0x9, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0xe, 0xff, 0xa0, 0x0, + 0xf, 0xff, 0xf6, 0x6f, 0xff, 0xf0, 0x0, 0x3, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x40, + 0x0, 0xf, 0xff, 0xf6, 0x6f, 0xff, 0xf0, 0x0, + 0x0, 0xef, 0xff, 0x20, 0x0, 0x0, 0xaf, 0xff, + 0x0, 0x0, 0xf, 0xff, 0xf6, 0x6f, 0xff, 0xf0, + 0x0, 0x0, 0x9f, 0xff, 0x80, 0x0, 0x0, 0xff, + 0xfa, 0x0, 0x0, 0xf, 0xff, 0xf6, 0x6f, 0xff, + 0xf0, 0x0, 0x0, 0x3f, 0xff, 0xd0, 0x0, 0x5, + 0xff, 0xf4, 0x0, 0x0, 0xf, 0xff, 0xf6, 0x6f, + 0xff, 0xf0, 0x0, 0x0, 0xe, 0xff, 0xf2, 0x0, + 0xa, 0xff, 0xe0, 0x0, 0x0, 0xf, 0xff, 0xf6, + 0x6f, 0xff, 0xf0, 0x0, 0x0, 0x9, 0xff, 0xf8, + 0x0, 0xf, 0xff, 0x90, 0x0, 0x0, 0xf, 0xff, + 0xf6, 0x6f, 0xff, 0xf0, 0x0, 0x0, 0x3, 0xff, + 0xfd, 0x0, 0x5f, 0xff, 0x40, 0x0, 0x0, 0xf, + 0xff, 0xf6, 0x6f, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0x20, 0xaf, 0xfe, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf6, 0x6f, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0x70, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf6, 0x6f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xc5, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf6, 0x6f, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xfb, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf6, 0x6f, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf6, 0x6f, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf6, + 0x6f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf6, 0x6f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf6, 0x6f, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf6, + + /* U+004E "N" */ + 0x3f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xfe, 0x3f, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xfe, 0x3f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xfe, 0x3f, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfe, + 0x3f, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xfe, 0x3f, 0xff, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xfe, 0x3f, 0xff, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xfe, 0x3f, 0xff, 0xfe, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfe, + 0x3f, 0xff, 0xf5, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xfe, 0x3f, 0xff, + 0xf2, 0x8f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xfe, 0x3f, 0xff, 0xf2, 0xd, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xfe, 0x3f, 0xff, 0xf2, 0x3, 0xff, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfe, + 0x3f, 0xff, 0xf2, 0x0, 0x9f, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xfe, 0x3f, 0xff, + 0xf2, 0x0, 0xd, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xfe, 0x3f, 0xff, 0xf2, 0x0, + 0x4, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xfe, 0x3f, 0xff, 0xf2, 0x0, 0x0, 0x9f, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfe, + 0x3f, 0xff, 0xf2, 0x0, 0x0, 0xe, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x7, 0xff, 0xfe, 0x3f, 0xff, + 0xf2, 0x0, 0x0, 0x4, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x7, 0xff, 0xfe, 0x3f, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xf9, 0x0, 0x0, 0x7, + 0xff, 0xfe, 0x3f, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xff, 0x40, 0x0, 0x7, 0xff, 0xfe, + 0x3f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xe0, 0x0, 0x7, 0xff, 0xfe, 0x3f, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf9, + 0x0, 0x7, 0xff, 0xfe, 0x3f, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0x30, 0x7, + 0xff, 0xfe, 0x3f, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xd0, 0x7, 0xff, 0xfe, + 0x3f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf8, 0x7, 0xff, 0xfe, 0x3f, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0x37, 0xff, 0xfe, 0x3f, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xd8, + 0xff, 0xfe, 0x3f, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfe, 0xff, 0xfe, + 0x3f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0xfe, 0x3f, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xfe, 0x3f, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xfe, 0x3f, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xfe, + 0x3f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xfe, 0x3f, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xfe, 0x3f, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xfe, + + /* U+004F "O" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x57, + 0x77, 0x64, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6b, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x82, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7e, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2d, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0xff, 0xb9, 0x89, 0xad, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xfb, 0x40, 0x0, 0x0, 0x0, 0x28, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x2, + 0xef, 0xff, 0xfe, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1b, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x6f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0xef, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xf3, 0x0, 0x4, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xfa, 0x0, 0xa, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0x0, 0xf, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x50, 0x3f, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x90, 0x6f, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xc0, 0x8f, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xe0, + 0xaf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf0, 0xbf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xf1, 0xbf, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xf1, 0xbf, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf1, 0xaf, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf0, 0x9f, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xe0, 0x6f, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xc0, 0x3f, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x90, + 0xe, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x50, 0xa, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0x10, 0x4, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xfa, 0x0, 0x0, 0xdf, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xf3, 0x0, 0x0, 0x5f, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xb0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1a, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xf9, 0x30, 0x0, 0x0, + 0x0, 0x17, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xef, 0xff, 0xff, 0xfe, 0xa9, + 0x78, 0xac, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6e, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5b, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x82, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0x56, 0x77, 0x64, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0050 "P" */ + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xec, 0xa8, 0x40, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe6, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x4f, 0xff, + 0xf5, 0x22, 0x22, 0x22, 0x22, 0x22, 0x35, 0x8e, + 0xff, 0xff, 0xf6, 0x4, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1b, 0xff, 0xff, + 0xe0, 0x4f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x54, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf9, 0x4f, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xc4, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xfe, 0x4f, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xe4, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xfd, 0x4f, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xb4, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xf7, 0x4f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, + 0xff, 0xff, 0x24, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5e, 0xff, 0xff, 0xb0, + 0x4f, 0xff, 0xf5, 0x22, 0x22, 0x22, 0x22, 0x23, + 0x58, 0xdf, 0xff, 0xff, 0xf2, 0x4, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb3, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xec, 0x96, + 0x10, 0x0, 0x0, 0x4, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+0051 "Q" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x57, + 0x77, 0x64, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6c, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x72, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7e, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x91, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2d, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xef, + 0xff, 0xff, 0xfe, 0xb9, 0x89, 0xad, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xfb, 0x40, 0x0, 0x0, 0x0, 0x17, + 0xef, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1a, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x5f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0xdf, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xf3, 0x0, 0x4, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xfa, 0x0, 0xa, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0x0, 0xf, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x40, 0x3f, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x90, 0x6f, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xc0, 0x8f, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xe0, + 0xaf, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf0, 0xbf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xf0, 0xbf, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xf1, 0xbf, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf1, 0xaf, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf0, 0x8f, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xe0, 0x6f, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xc0, 0x3f, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x90, + 0xe, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x50, 0xa, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0x10, 0x4, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0x93, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xfb, 0x0, 0x0, 0xcf, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xd5, 0x0, 0x0, + 0xdf, 0xff, 0xf3, 0x0, 0x0, 0x4f, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xc2, + 0xa, 0xff, 0xff, 0xb0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xd1, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xff, 0xaf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, 0x39, + 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xfa, 0x30, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xef, 0xff, 0xff, 0xfe, 0xa9, + 0x78, 0xad, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2d, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9a, 0xff, + 0xff, 0xfa, 0x20, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x6c, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x71, 0x0, + 0x6f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0x67, 0x77, 0x64, 0x10, 0x0, + 0x0, 0x2, 0xbf, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xdf, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x50, + + /* U+0052 "R" */ + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xed, 0xb8, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x40, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xfe, 0xee, 0xee, 0xee, 0xee, 0xee, + 0xef, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0x9f, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xef, 0xff, 0xf8, 0x0, 0x0, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfe, 0x0, 0x0, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x20, 0x0, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x40, 0x0, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x40, 0x0, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x30, 0x0, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0x10, 0x0, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x48, 0xdf, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xa3, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x1, 0x36, 0xcf, + 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xfc, 0x0, 0x0, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x60, 0x0, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xe1, 0x0, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf9, 0x0, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x30, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xc0, + + /* U+0053 "S" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x35, 0x67, 0x76, + 0x41, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xd8, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xe2, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xfc, 0xa9, 0xab, + 0xdf, 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xb3, 0x0, 0x0, 0x0, 0x1, 0x8f, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0xcf, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xdf, 0xff, + 0xf6, 0x0, 0x2, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfc, 0x0, + 0x5, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0x10, 0x7, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0x40, 0x8, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0x60, 0x6, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x32, 0x10, 0x0, + 0x2, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xfd, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xfe, 0x94, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x84, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfb, 0x72, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x8d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x27, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x37, + 0xbf, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5b, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3d, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xf2, + 0x46, 0x79, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf5, 0xcf, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf7, 0xaf, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf7, 0x7f, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf5, + 0x2f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf3, 0xc, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xe0, 0x3, 0xff, 0xff, 0xfc, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2c, 0xff, + 0xff, 0x70, 0x0, 0x9f, 0xff, 0xff, 0xfa, 0x40, + 0x0, 0x0, 0x0, 0x39, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xdb, 0xab, + 0xcf, 0xff, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x20, 0x0, 0x0, 0x0, 0x5, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xae, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x82, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x14, 0x56, 0x77, + 0x64, 0x10, 0x0, 0x0, 0x0, 0x0, + + /* U+0054 "T" */ + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0x22, 0x22, 0x22, 0x22, 0x22, 0x2b, 0xff, 0xfe, + 0x22, 0x22, 0x22, 0x22, 0x22, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0055 "U" */ + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xfd, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xfd, 0x2f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xfd, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xfd, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xfd, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xfd, 0x2f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xfd, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xfd, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xfd, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xfd, 0x2f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xfd, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xfd, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xfd, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xfd, 0x2f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xfd, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xfd, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xfd, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xfd, 0x2f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xfd, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xfd, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xfd, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xfc, 0x1f, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfc, 0xf, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfa, + 0xe, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf9, 0xb, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xf6, 0x8, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xf3, 0x4, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf0, + 0x0, 0xef, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xa0, 0x0, 0x8f, + 0xff, 0xfe, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0x30, 0x0, 0x1e, 0xff, 0xff, + 0xfa, 0x30, 0x0, 0x0, 0x1, 0x5c, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, + 0xcb, 0xbc, 0xef, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x10, 0x0, 0x0, 0x0, + 0x3, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x71, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x25, + 0x67, 0x77, 0x63, 0x10, 0x0, 0x0, 0x0, 0x0, + + /* U+0056 "V" */ + 0x9f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf7, + 0x3f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf1, + 0xd, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xb0, + 0x6, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x50, + 0x1, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfe, 0x0, + 0x0, 0xaf, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf8, 0x0, + 0x0, 0x4f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf2, 0x0, + 0x0, 0xe, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xc0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x2, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x50, 0x0, + 0x0, 0x7, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xb0, 0x0, + 0x0, 0xd, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf1, 0x0, + 0x0, 0x2f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf6, 0x0, + 0x0, 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfc, 0x0, + 0x0, 0xef, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x10, + 0x4, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, + 0x9, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xc0, + 0xf, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf1, + 0x4f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf6, + 0x9f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfb, + 0xef, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0057 "W" */ + 0x5f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x81, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xf4, 0xd, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0x0, 0x9f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xb0, 0x5, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xdf, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf7, + 0x0, 0x1f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf5, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x30, 0x0, + 0xcf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xd, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xe0, 0x0, 0x8, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xc0, 0x9f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xfa, 0x0, 0x0, 0x4f, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf7, 0x5, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0x60, 0x0, 0x0, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x30, 0x1f, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf1, + 0x0, 0x0, 0xc, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xe0, 0x0, 0xcf, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xfa, 0x0, 0x8, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x90, 0x0, 0x0, 0x3, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0x60, 0x0, 0x3f, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xf4, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf2, 0x0, + 0x0, 0xff, 0xff, 0x20, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, + 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, 0x0, 0xb, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x90, 0x0, 0x0, 0x6f, 0xff, + 0xb0, 0x0, 0x0, 0x9, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xe0, 0x0, 0x0, 0xa, + 0xff, 0xf4, 0x0, 0x0, 0x2, 0xff, 0xff, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0x20, 0x0, 0x0, 0xef, 0xff, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xf4, 0x0, 0x0, + 0x1f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xf6, 0x0, 0x0, 0x3f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x80, 0x0, 0x5, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x90, 0x0, 0x7, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xfc, 0x0, 0x0, 0x9f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfd, 0x0, + 0x0, 0xbf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xf0, 0x0, 0xc, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xf1, 0x0, 0xf, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x40, 0x0, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x40, 0x4, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf8, 0x0, + 0x4f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xf8, 0x0, 0x9f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xc0, 0x8, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xb0, 0xd, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0x0, 0xcf, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x1, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf2, 0xf, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf2, 0x4f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x53, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x58, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf8, + 0x7f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xf8, 0xcf, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xba, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xcf, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xfe, 0xdf, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0058 "X" */ + 0x0, 0xdf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x60, + 0x0, 0x3f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfa, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfc, 0x0, + 0x0, 0x3f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x70, + 0x1, 0xef, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf2, + 0xa, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xfc, + 0x4f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfb, + 0xdf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xf2, + 0x3f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x70, + 0x9, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfc, 0x0, + 0x0, 0xdf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf4, 0x0, + 0x1, 0xef, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfe, 0x10, + 0xb, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xa0, + 0x6f, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf5, + + /* U+0059 "Y" */ + 0x8f, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xf4, + 0xd, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x90, + 0x3, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfe, 0x0, + 0x0, 0x9f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf4, 0x0, + 0x0, 0xd, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x1f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfa, 0x0, + 0x0, 0xbf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0x40, + 0x5, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xd0, + 0xd, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf6, + 0x7f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xfe, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+005A "Z" */ + 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x2f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf7, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x2, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x22, 0x22, 0x22, 0x27, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xef, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xfe, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x82, 0x22, + 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x2, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf0, 0x2f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x0, + + /* U+005B "[" */ + 0xdf, 0xff, 0xff, 0xff, 0xf8, 0xdf, 0xff, 0xff, + 0xff, 0xf8, 0xdf, 0xff, 0xff, 0xff, 0xf8, 0xdf, + 0xff, 0xb9, 0x99, 0x94, 0xdf, 0xff, 0x60, 0x0, + 0x0, 0xdf, 0xff, 0x60, 0x0, 0x0, 0xdf, 0xff, + 0x60, 0x0, 0x0, 0xdf, 0xff, 0x60, 0x0, 0x0, + 0xdf, 0xff, 0x60, 0x0, 0x0, 0xdf, 0xff, 0x60, + 0x0, 0x0, 0xdf, 0xff, 0x60, 0x0, 0x0, 0xdf, + 0xff, 0x60, 0x0, 0x0, 0xdf, 0xff, 0x60, 0x0, + 0x0, 0xdf, 0xff, 0x60, 0x0, 0x0, 0xdf, 0xff, + 0x60, 0x0, 0x0, 0xdf, 0xff, 0x60, 0x0, 0x0, + 0xdf, 0xff, 0x60, 0x0, 0x0, 0xdf, 0xff, 0x60, + 0x0, 0x0, 0xdf, 0xff, 0x60, 0x0, 0x0, 0xdf, + 0xff, 0x60, 0x0, 0x0, 0xdf, 0xff, 0x60, 0x0, + 0x0, 0xdf, 0xff, 0x60, 0x0, 0x0, 0xdf, 0xff, + 0x60, 0x0, 0x0, 0xdf, 0xff, 0x60, 0x0, 0x0, + 0xdf, 0xff, 0x60, 0x0, 0x0, 0xdf, 0xff, 0x60, + 0x0, 0x0, 0xdf, 0xff, 0x60, 0x0, 0x0, 0xdf, + 0xff, 0x60, 0x0, 0x0, 0xdf, 0xff, 0x60, 0x0, + 0x0, 0xdf, 0xff, 0x60, 0x0, 0x0, 0xdf, 0xff, + 0x60, 0x0, 0x0, 0xdf, 0xff, 0x60, 0x0, 0x0, + 0xdf, 0xff, 0x60, 0x0, 0x0, 0xdf, 0xff, 0x60, + 0x0, 0x0, 0xdf, 0xff, 0x60, 0x0, 0x0, 0xdf, + 0xff, 0x60, 0x0, 0x0, 0xdf, 0xff, 0x60, 0x0, + 0x0, 0xdf, 0xff, 0x60, 0x0, 0x0, 0xdf, 0xff, + 0x60, 0x0, 0x0, 0xdf, 0xff, 0x60, 0x0, 0x0, + 0xdf, 0xff, 0x60, 0x0, 0x0, 0xdf, 0xff, 0xb9, + 0x99, 0x94, 0xdf, 0xff, 0xff, 0xff, 0xf8, 0xdf, + 0xff, 0xff, 0xff, 0xf8, 0xdf, 0xff, 0xff, 0xff, + 0xf8, + + /* U+005C "\\" */ + 0x78, 0x83, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf3, + + /* U+005D "]" */ + 0x2f, 0xff, 0xff, 0xff, 0xff, 0x22, 0xff, 0xff, + 0xff, 0xff, 0xf2, 0x2f, 0xff, 0xff, 0xff, 0xff, + 0x21, 0x99, 0x99, 0x9f, 0xff, 0xf2, 0x0, 0x0, + 0x1, 0xff, 0xff, 0x20, 0x0, 0x0, 0x1f, 0xff, + 0xf2, 0x0, 0x0, 0x1, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x1f, 0xff, 0xf2, 0x0, 0x0, 0x1, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x1f, 0xff, 0xf2, 0x0, + 0x0, 0x1, 0xff, 0xff, 0x20, 0x0, 0x0, 0x1f, + 0xff, 0xf2, 0x0, 0x0, 0x1, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x1f, 0xff, 0xf2, 0x0, 0x0, 0x1, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x1f, 0xff, 0xf2, + 0x0, 0x0, 0x1, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x1f, 0xff, 0xf2, 0x0, 0x0, 0x1, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x1f, 0xff, 0xf2, 0x0, 0x0, + 0x1, 0xff, 0xff, 0x20, 0x0, 0x0, 0x1f, 0xff, + 0xf2, 0x0, 0x0, 0x1, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x1f, 0xff, 0xf2, 0x0, 0x0, 0x1, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x1f, 0xff, 0xf2, 0x0, + 0x0, 0x1, 0xff, 0xff, 0x20, 0x0, 0x0, 0x1f, + 0xff, 0xf2, 0x0, 0x0, 0x1, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x1f, 0xff, 0xf2, 0x0, 0x0, 0x1, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x1f, 0xff, 0xf2, + 0x0, 0x0, 0x1, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x1f, 0xff, 0xf2, 0x0, 0x0, 0x1, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x1f, 0xff, 0xf2, 0x0, 0x0, + 0x1, 0xff, 0xff, 0x20, 0x0, 0x0, 0x1f, 0xff, + 0xf2, 0x0, 0x0, 0x1, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x1f, 0xff, 0xf2, 0x0, 0x0, 0x1, 0xff, + 0xff, 0x21, 0x99, 0x99, 0x9f, 0xff, 0xf2, 0x2f, + 0xff, 0xff, 0xff, 0xff, 0x22, 0xff, 0xff, 0xff, + 0xff, 0xf2, 0x2f, 0xff, 0xff, 0xff, 0xff, 0x20, + + /* U+005E "^" */ + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xe8, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf9, 0x1f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x20, 0xaf, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xc0, 0x4, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf6, 0x0, 0xd, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0x0, 0x0, 0x7f, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x90, + 0x0, 0x1, 0xff, 0xfe, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf3, 0x0, 0x0, 0xa, 0xff, 0xf6, 0x0, + 0x0, 0x5, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xd0, 0x0, 0x0, 0xcf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x40, 0x0, 0x3f, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfb, 0x0, + 0xa, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf2, 0x1, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x90, 0x8f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x10, + + /* U+005F "_" */ + 0x2, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x22, 0x22, 0x22, 0x22, 0x21, 0x4f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x4f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + + /* U+0060 "`" */ + 0x7b, 0xbb, 0xba, 0x0, 0x1, 0xdf, 0xff, 0xf4, + 0x0, 0x2, 0xff, 0xff, 0xc0, 0x0, 0x5, 0xff, + 0xff, 0x40, 0x0, 0x8, 0xff, 0xfb, 0x0, 0x0, + 0xb, 0xff, 0xf3, 0x0, 0x0, 0xd, 0xff, 0xa0, + + /* U+0061 "a" */ + 0x0, 0x0, 0x0, 0x0, 0x3, 0x67, 0x77, 0x64, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6b, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0x71, 0x0, 0x0, + 0x0, 0x0, 0x2d, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x30, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x1e, 0xff, 0xff, 0xb5, 0x21, 0x12, 0x49, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x8f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, 0x0, + 0x0, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0x30, 0x4, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x50, + 0x1, 0x57, 0x99, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x5a, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x3, 0x57, 0x9c, 0xff, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x2, 0x8c, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x1, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0xef, 0xff, 0x60, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xda, 0x74, + 0x0, 0xdf, 0xff, 0x60, 0x1, 0xff, 0xff, 0xff, + 0xa5, 0x20, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x60, + 0x9, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0x60, 0xe, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x60, + 0x1f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0x70, 0x2f, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x70, + 0x1f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x70, 0xd, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0x80, + 0x7, 0xff, 0xff, 0xf7, 0x10, 0x0, 0x16, 0xdf, + 0xff, 0xff, 0xff, 0x90, 0x0, 0xcf, 0xff, 0xff, + 0xfe, 0xef, 0xff, 0xff, 0xf9, 0x6f, 0xff, 0xd0, + 0x0, 0x1c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x50, 0x3f, 0xff, 0xf1, 0x0, 0x0, 0x7d, 0xff, + 0xff, 0xff, 0xfc, 0x60, 0x0, 0xd, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x25, 0x77, 0x64, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0062 "b" */ + 0xcf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0x70, 0x0, 0x4, + 0x67, 0x64, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x70, 0x1a, 0xff, 0xff, 0xff, 0xf9, 0x10, 0x0, + 0x0, 0xcf, 0xff, 0x74, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0xcf, 0xff, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0xcf, + 0xff, 0xff, 0xff, 0x83, 0x11, 0x49, 0xff, 0xff, + 0xf4, 0x0, 0xcf, 0xff, 0xff, 0xd2, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xfe, 0x0, 0xcf, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x70, + 0xcf, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xd0, 0xcf, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf3, 0xcf, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf6, 0xcf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfa, 0xcf, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfb, 0xcf, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xfc, 0xcf, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xfc, 0xcf, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xfb, + 0xcf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xfa, 0xcf, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf8, 0xcf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf5, 0xcf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf1, 0xcf, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xb0, 0xcf, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0x40, 0xcf, 0xff, 0xff, 0xc1, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xfb, 0x0, 0xcf, 0xff, 0xff, + 0xfe, 0x72, 0x12, 0x5b, 0xff, 0xff, 0xe1, 0x0, + 0xcf, 0xff, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x30, 0x0, 0xcf, 0xff, 0x25, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd2, 0x0, 0x0, 0xcf, 0xff, + 0x20, 0x2b, 0xff, 0xff, 0xff, 0xd6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x15, 0x77, 0x52, + 0x0, 0x0, 0x0, 0x0, + + /* U+0063 "c" */ + 0x0, 0x0, 0x0, 0x0, 0x3, 0x56, 0x76, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x9e, + 0xff, 0xff, 0xff, 0xfb, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xfa, 0x42, 0x12, 0x6d, 0xff, 0xff, + 0xa0, 0x0, 0x3, 0xff, 0xff, 0xe3, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0x30, 0x0, 0xbf, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xfa, + 0x0, 0x2f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xe0, 0x7, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xfd, 0xa8, 0x0, + 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x11, 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xc5, 0x7, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0x40, 0x2f, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf1, 0x0, 0xbf, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xfa, 0x0, 0x3, 0xff, 0xff, 0xc1, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0x20, 0x0, 0x8, 0xff, + 0xff, 0xf8, 0x31, 0x12, 0x6d, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x2, 0x9e, 0xff, 0xff, 0xff, 0xfa, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0x56, 0x76, 0x40, 0x0, 0x0, 0x0, 0x0, + + /* U+0064 "d" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x1, 0x56, 0x75, 0x30, 0x0, + 0xe, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x5c, 0xff, + 0xff, 0xff, 0xd6, 0x0, 0xef, 0xff, 0x50, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xe, + 0xff, 0xf5, 0x0, 0x1, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfa, 0xef, 0xff, 0x50, 0x0, 0xbf, + 0xff, 0xfe, 0x73, 0x12, 0x5b, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0x5f, 0xff, 0xfb, 0x10, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0x50, 0xd, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf5, + 0x4, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0x50, 0x9f, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf5, 0xd, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0x50, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf5, 0x2f, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0x53, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf5, 0x4f, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0x53, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xf5, 0x2f, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x50, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf5, 0xc, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x50, 0x8f, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf5, 0x2, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0x50, 0xc, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xf5, 0x0, 0x3f, 0xff, 0xfd, 0x20, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0x50, 0x0, 0x8f, 0xff, + 0xff, 0x83, 0x11, 0x4b, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x9f, 0xff, 0x50, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x19, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x3b, 0xff, 0xff, 0xff, 0xe8, 0x0, + 0x9f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x1, 0x46, + 0x76, 0x40, 0x0, 0x0, 0x0, 0x0, + + /* U+0065 "e" */ + 0x0, 0x0, 0x0, 0x0, 0x2, 0x56, 0x76, 0x51, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xdf, 0xff, 0xff, 0xff, 0xc6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc2, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x30, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xfa, 0x52, 0x12, 0x5b, + 0xff, 0xff, 0xe1, 0x0, 0x0, 0x1e, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x4e, 0xff, 0xfc, 0x0, + 0x0, 0x9f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0x50, 0x0, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xc0, + 0x6, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf1, 0xa, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf5, + 0xd, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf8, 0xf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x1f, 0xff, 0xfa, 0x88, 0x88, 0x88, 0x88, 0x88, + 0x88, 0x88, 0x88, 0x86, 0xf, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, + 0x7, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xfd, 0xb5, 0x2, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf4, + 0x0, 0xbf, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xd0, 0x0, 0x2f, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x2d, 0xff, 0xff, 0x50, + 0x0, 0x6, 0xff, 0xff, 0xfc, 0x62, 0x11, 0x49, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x5, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xdf, 0xff, 0xff, 0xff, 0xfa, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x56, 0x77, 0x63, + 0x0, 0x0, 0x0, 0x0, + + /* U+0066 "f" */ + 0x0, 0x0, 0x0, 0x0, 0x25, 0x77, 0x64, 0x20, + 0x0, 0x0, 0x3, 0xcf, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x1, 0xef, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xa7, 0x79, 0x30, 0x0, 0xa, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x40, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x20, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf2, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x20, 0x35, 0x55, 0xef, 0xff, 0x85, 0x55, 0x50, + 0x0, 0x0, 0xe, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xf4, 0x0, 0x0, 0x0, + + /* U+0067 "g" */ + 0x0, 0x0, 0x0, 0x0, 0x15, 0x67, 0x64, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xcf, + 0xff, 0xff, 0xfe, 0x80, 0x5, 0xff, 0xf9, 0x0, + 0x0, 0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd3, + 0x5f, 0xff, 0x90, 0x0, 0x1d, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe7, 0xff, 0xf9, 0x0, 0xc, + 0xff, 0xff, 0xe7, 0x31, 0x24, 0xaf, 0xff, 0xff, + 0xff, 0x90, 0x6, 0xff, 0xff, 0xb1, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xf9, 0x0, 0xef, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0x90, 0x5f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf9, 0xb, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x90, + 0xef, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xf9, 0x2f, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x93, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xf9, 0x4f, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x95, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xf9, 0x4f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x93, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf9, + 0xf, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x90, 0xdf, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf9, 0x8, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0x90, 0x2f, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf9, 0x0, 0xaf, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0x90, 0x1, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x2, 0xbf, 0xff, 0xff, 0xf9, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xb9, 0xac, 0xff, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x7b, 0xff, 0xf8, 0x0, 0x0, 0x3, 0xdf, + 0xff, 0xff, 0xff, 0xfe, 0x50, 0xbf, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x49, 0xde, 0xfe, 0xb6, 0x10, + 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf4, 0x6, 0xa8, 0x52, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0x20, 0x6f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xe0, 0x4, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xfa, 0x0, 0xe, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x2c, 0xff, 0xff, 0x30, + 0x0, 0x7f, 0xff, 0xfe, 0x73, 0x11, 0x24, 0x9f, + 0xff, 0xff, 0x90, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x4b, 0xff, 0xff, + 0xff, 0xff, 0xe9, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x36, 0x77, 0x75, 0x20, 0x0, 0x0, + 0x0, 0x0, + + /* U+0068 "h" */ + 0xcf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf7, 0x0, 0x0, 0x35, 0x77, 0x63, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x70, 0x7, 0xdf, 0xff, 0xff, + 0xff, 0x81, 0x0, 0xc, 0xff, 0xf7, 0x2d, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd2, 0x0, 0xcf, 0xff, + 0x9e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, + 0xc, 0xff, 0xff, 0xff, 0xfb, 0x64, 0x35, 0xaf, + 0xff, 0xff, 0x70, 0xcf, 0xff, 0xff, 0xd3, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xfe, 0xc, 0xff, 0xff, + 0xd1, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf2, + 0xcf, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0x5c, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xf6, 0xcf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x7c, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xf8, 0xcf, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x8c, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf8, 0xcf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x8c, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf8, 0xcf, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x8c, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf8, 0xcf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x8c, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xf8, 0xcf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x8c, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf8, 0xcf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x8c, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf8, + 0xcf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x8c, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf8, 0xcf, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x80, + + /* U+0069 "i" */ + 0xcf, 0xff, 0x7c, 0xff, 0xf7, 0xcf, 0xff, 0x7c, + 0xff, 0xf7, 0xbf, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x7c, 0xff, 0xf7, 0xcf, 0xff, + 0x7c, 0xff, 0xf7, 0xcf, 0xff, 0x7c, 0xff, 0xf7, + 0xcf, 0xff, 0x7c, 0xff, 0xf7, 0xcf, 0xff, 0x7c, + 0xff, 0xf7, 0xcf, 0xff, 0x7c, 0xff, 0xf7, 0xcf, + 0xff, 0x7c, 0xff, 0xf7, 0xcf, 0xff, 0x7c, 0xff, + 0xf7, 0xcf, 0xff, 0x7c, 0xff, 0xf7, 0xcf, 0xff, + 0x7c, 0xff, 0xf7, 0xcf, 0xff, 0x7c, 0xff, 0xf7, + 0xcf, 0xff, 0x7c, 0xff, 0xf7, 0xcf, 0xff, 0x70, + + /* U+006A "j" */ + 0x0, 0x0, 0x0, 0xcf, 0xff, 0x70, 0x0, 0x0, + 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x70, 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x70, 0x0, 0x0, 0xc, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x70, + 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x70, 0x0, 0x0, 0xc, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0x70, 0x0, 0x0, + 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x70, 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x70, 0x0, 0x0, 0xc, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x70, 0x0, + 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x70, 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x70, 0x0, 0x0, 0xc, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x70, + 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x70, 0x0, 0x0, 0xc, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0x70, 0x0, 0x0, + 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x70, 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x70, 0x0, 0x0, 0xc, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x60, 0x0, + 0x0, 0xf, 0xff, 0xf4, 0x0, 0x0, 0x3, 0xff, + 0xff, 0x20, 0x36, 0x47, 0xef, 0xff, 0xe0, 0x8, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0xcf, 0xff, 0xff, + 0xfe, 0x10, 0xf, 0xff, 0xff, 0xfc, 0x20, 0x0, + 0x25, 0x77, 0x62, 0x0, 0x0, + + /* U+006B "k" */ + 0xdf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x2, + 0xef, 0xff, 0xf5, 0xd, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x2, 0xef, 0xff, 0xf5, 0x0, 0xdf, 0xff, + 0x60, 0x0, 0x0, 0x2, 0xef, 0xff, 0xf5, 0x0, + 0xd, 0xff, 0xf6, 0x0, 0x0, 0x2, 0xef, 0xff, + 0xf4, 0x0, 0x0, 0xdf, 0xff, 0x60, 0x0, 0x2, + 0xef, 0xff, 0xf4, 0x0, 0x0, 0xd, 0xff, 0xf6, + 0x0, 0x2, 0xef, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x60, 0x1, 0xdf, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xf6, 0x1, 0xdf, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x61, + 0xdf, 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xf7, 0xdf, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xe9, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xe2, 0xc, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xe2, 0x0, + 0x2f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xf6, 0x0, 0x0, 0x8f, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x60, 0x0, 0x0, 0xdf, 0xff, + 0xf2, 0x0, 0x0, 0xd, 0xff, 0xf6, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xc0, 0x0, 0x0, 0xdf, 0xff, + 0x60, 0x0, 0x0, 0x9, 0xff, 0xff, 0x70, 0x0, + 0xd, 0xff, 0xf6, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0x20, 0x0, 0xdf, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xfc, 0x0, 0xd, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf7, 0x0, + 0xdf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xff, 0xf2, 0xd, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xc0, 0xdf, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x70, + + /* U+006C "l" */ + 0xdf, 0xff, 0x6d, 0xff, 0xf6, 0xdf, 0xff, 0x6d, + 0xff, 0xf6, 0xdf, 0xff, 0x6d, 0xff, 0xf6, 0xdf, + 0xff, 0x6d, 0xff, 0xf6, 0xdf, 0xff, 0x6d, 0xff, + 0xf6, 0xdf, 0xff, 0x6d, 0xff, 0xf6, 0xdf, 0xff, + 0x6d, 0xff, 0xf6, 0xdf, 0xff, 0x6d, 0xff, 0xf6, + 0xdf, 0xff, 0x6d, 0xff, 0xf6, 0xdf, 0xff, 0x6d, + 0xff, 0xf6, 0xdf, 0xff, 0x6d, 0xff, 0xf6, 0xdf, + 0xff, 0x6d, 0xff, 0xf6, 0xdf, 0xff, 0x6d, 0xff, + 0xf6, 0xdf, 0xff, 0x6d, 0xff, 0xf6, 0xdf, 0xff, + 0x6d, 0xff, 0xf6, 0xdf, 0xff, 0x6d, 0xff, 0xf6, + 0xdf, 0xff, 0x6d, 0xff, 0xf6, 0xdf, 0xff, 0x60, + + /* U+006D "m" */ + 0x0, 0x0, 0x0, 0x0, 0x4, 0x67, 0x74, 0x10, + 0x0, 0x0, 0x0, 0x1, 0x57, 0x76, 0x30, 0x0, + 0x0, 0xdf, 0xfe, 0x0, 0x1a, 0xff, 0xff, 0xff, + 0xfa, 0x10, 0x0, 0x2, 0xbf, 0xff, 0xff, 0xfe, + 0x70, 0x0, 0xdf, 0xfe, 0x4, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe2, 0x0, 0x6f, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x0, 0xdf, 0xfe, 0x3f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x6, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x90, 0xdf, 0xff, 0xef, 0xff, + 0x95, 0x45, 0xaf, 0xff, 0xff, 0x8f, 0xff, 0xd7, + 0x44, 0x6b, 0xff, 0xff, 0xf1, 0xdf, 0xff, 0xff, + 0xb1, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf7, 0xdf, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfa, 0xdf, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfc, + 0xdf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xfd, 0xdf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xfe, 0xdf, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xfe, 0xdf, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xfe, 0xdf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xfe, 0xdf, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xfe, 0xdf, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfe, 0xdf, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfe, + 0xdf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xfe, 0xdf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xfe, 0xdf, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xfe, 0xdf, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xfe, 0xdf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xfe, 0xdf, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xfe, 0xdf, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfe, 0xdf, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfe, + 0xdf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xfe, 0xdf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xfe, + + /* U+006E "n" */ + 0x0, 0x0, 0x0, 0x0, 0x3, 0x67, 0x76, 0x30, + 0x0, 0x0, 0xb, 0xff, 0xf1, 0x0, 0x7e, 0xff, + 0xff, 0xff, 0xe7, 0x0, 0x0, 0xbf, 0xff, 0x12, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x20, 0xb, + 0xff, 0xf3, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x0, 0xbf, 0xff, 0xdf, 0xff, 0xb6, 0x44, + 0x6b, 0xff, 0xff, 0xf8, 0xb, 0xff, 0xff, 0xfd, + 0x30, 0x0, 0x0, 0x5, 0xff, 0xff, 0xe0, 0xbf, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x2b, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf5, 0xbf, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x6b, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf7, 0xbf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x7b, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, 0xbf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x7b, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf7, 0xbf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x7b, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, + 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x7b, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf7, 0xbf, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x7b, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xf7, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x7b, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, 0xbf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x7b, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf7, 0xbf, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x7b, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf7, + + /* U+006F "o" */ + 0x0, 0x0, 0x0, 0x0, 0x2, 0x56, 0x76, 0x51, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x8e, 0xff, 0xff, 0xff, 0xfd, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd4, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfa, 0x52, + 0x12, 0x6c, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xe3, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xe1, 0x0, 0x0, 0xdf, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x80, 0x0, + 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0x0, 0xa, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf5, + 0x0, 0xef, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x90, 0x1f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xfc, 0x2, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xe0, 0x3f, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0x4, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf0, 0x3f, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xfe, 0x2, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xd0, + 0x1f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfc, 0x0, 0xef, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x80, 0xa, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf5, 0x0, 0x5f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0x0, 0x0, 0xdf, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0x80, 0x0, 0x5, + 0xff, 0xff, 0xe3, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xe1, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfa, + 0x42, 0x12, 0x6c, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xe4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x8e, 0xff, 0xff, 0xff, + 0xfd, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0x56, 0x76, 0x51, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0070 "p" */ + 0x0, 0x0, 0x0, 0x0, 0x4, 0x67, 0x64, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x10, 0x1a, 0xff, + 0xff, 0xff, 0xfa, 0x20, 0x0, 0x0, 0xbf, 0xff, + 0x14, 0xef, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0xbf, 0xff, 0x5f, 0xff, 0xff, 0xef, 0xff, + 0xff, 0xff, 0x70, 0x0, 0xbf, 0xff, 0xff, 0xfe, + 0x71, 0x0, 0x17, 0xff, 0xff, 0xf4, 0x0, 0xbf, + 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x2e, 0xff, + 0xfe, 0x10, 0xbf, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x70, 0xbf, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xe0, + 0xbf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf4, 0xbf, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf7, 0xbf, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xfa, 0xbf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xfc, 0xbf, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfd, 0xbf, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xfd, 0xbf, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xfc, 0xbf, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfb, + 0xbf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf9, 0xbf, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xf5, 0xbf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xf1, 0xbf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xb0, 0xbf, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x50, 0xbf, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xfb, 0x0, 0xbf, 0xff, 0xff, 0xfe, 0x72, 0x12, + 0x5c, 0xff, 0xff, 0xf2, 0x0, 0xbf, 0xff, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, + 0xbf, 0xff, 0x75, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd3, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x2b, 0xff, + 0xff, 0xff, 0xd7, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x70, 0x0, 0x15, 0x77, 0x53, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0071 "q" */ + 0x0, 0x0, 0x0, 0x0, 0x15, 0x67, 0x53, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xcf, + 0xff, 0xff, 0xfd, 0x60, 0x7, 0xff, 0xf5, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, + 0x7f, 0xff, 0x50, 0x0, 0x1c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb7, 0xff, 0xf5, 0x0, 0xb, + 0xff, 0xff, 0xd5, 0x0, 0x3, 0x9f, 0xff, 0xef, + 0xff, 0x50, 0x5, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xf5, 0x0, 0xdf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0x50, 0x4f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xf5, 0x9, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x50, + 0xdf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xf5, 0xf, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x51, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xf5, 0x2f, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0x53, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf5, 0x2f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x51, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf5, + 0xe, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0x50, 0xbf, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf5, 0x7, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0x50, 0x1f, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf5, 0x0, 0x9f, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0x50, 0x1, 0xef, 0xff, 0xe2, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xf5, 0x0, 0x5, 0xff, + 0xff, 0xf9, 0x31, 0x14, 0xaf, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xde, 0xff, 0xf5, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd1, 0xef, 0xff, 0x50, + 0x0, 0x0, 0x2, 0xaf, 0xff, 0xff, 0xfe, 0x70, + 0xe, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x4, + 0x67, 0x63, 0x0, 0x0, 0xef, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xf5, + + /* U+0072 "r" */ + 0x0, 0x0, 0x0, 0x1, 0x67, 0x62, 0x0, 0xef, + 0xfe, 0x0, 0x7f, 0xff, 0xff, 0xc3, 0xef, 0xfe, + 0x7, 0xff, 0xff, 0xff, 0xf6, 0xef, 0xfe, 0x4f, + 0xff, 0xff, 0xff, 0xf1, 0xef, 0xfe, 0xdf, 0xff, + 0xff, 0xff, 0xa0, 0xef, 0xff, 0xff, 0xd4, 0x0, + 0x28, 0x40, 0xef, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + + /* U+0073 "s" */ + 0x0, 0x0, 0x0, 0x3, 0x67, 0x76, 0x52, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x19, 0xef, 0xff, + 0xff, 0xff, 0xe9, 0x20, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x1, 0xff, 0xff, 0xe8, + 0x41, 0x1, 0x38, 0xff, 0xff, 0xf4, 0x0, 0x7, + 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x2e, 0xff, + 0xfb, 0x0, 0xb, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0x0, 0xc, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xfe, 0xca, 0x10, + 0xb, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xa3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0xd8, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xb6, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x71, 0x0, 0x0, 0x0, + 0x0, 0x19, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x4, 0x9e, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x26, 0xaf, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5c, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf0, 0x4b, 0xdf, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xf1, 0x4f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf1, 0xe, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xe0, 0x8, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0x80, 0x1, 0xef, 0xff, 0xfc, 0x62, 0x11, + 0x25, 0xbf, 0xff, 0xfe, 0x10, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x3, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x30, 0x0, 0x0, 0x0, 0x6, 0xdf, 0xff, + 0xff, 0xff, 0xfd, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x46, 0x77, 0x64, 0x10, 0x0, 0x0, + 0x0, + + /* U+0074 "t" */ + 0x0, 0x0, 0x0, 0x8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4e, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0x10, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf5, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x53, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x15, 0x56, + 0xff, 0xff, 0x65, 0x55, 0x10, 0x0, 0x2f, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xfa, + 0x89, 0x30, 0x0, 0xb, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x4e, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x4, 0x67, 0x75, 0x30, + + /* U+0075 "u" */ + 0xdf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0x5d, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf5, 0xdf, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x5d, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf5, 0xdf, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0x5d, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf5, 0xdf, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0x5d, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf5, 0xdf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x5d, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xf5, 0xdf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0x5d, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xf5, 0xdf, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x5d, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xf5, 0xdf, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0x5d, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf5, + 0xcf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0x5c, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xf5, 0xaf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0x57, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xf5, 0x4f, 0xff, 0xfd, 0x20, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0x50, 0xdf, 0xff, 0xff, + 0x95, 0x34, 0x7d, 0xff, 0xfc, 0xff, 0xf5, 0x4, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x6f, + 0xff, 0x50, 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf7, 0x6, 0xff, 0xf5, 0x0, 0x2, 0xaf, 0xff, + 0xff, 0xff, 0xb3, 0x0, 0x6f, 0xff, 0x50, 0x0, + 0x0, 0x4, 0x67, 0x75, 0x10, 0x0, 0x0, 0x0, + 0x0, + + /* U+0076 "v" */ + 0x3f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf3, 0xd, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, + 0x7, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x70, 0x1, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x10, + 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xfb, 0x0, 0x0, 0x4f, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf5, 0x0, + 0x0, 0xe, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf0, 0x0, 0x0, 0x8, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x90, 0x0, + 0x0, 0x2, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x70, 0x0, 0x0, 0x5, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xc0, 0x0, 0x0, 0xb, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xf2, 0x0, 0x0, 0x1f, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xf8, 0x0, 0x0, 0x6f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xfe, 0x0, 0x0, 0xcf, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x30, 0x2, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0x90, 0x8, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xe0, 0xd, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf3, 0x3f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf8, 0x8f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xfd, 0xdf, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, + + /* U+0077 "w" */ + 0x9f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x34, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xe0, 0xf, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf9, 0x0, 0xbf, 0xff, 0x80, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0x40, 0x6, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf0, 0x0, + 0x1f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfa, + 0x0, 0x0, 0xcf, 0xff, 0x60, 0x0, 0x0, 0x7, + 0xff, 0xfa, 0xff, 0xf4, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0x50, 0x0, 0x7, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0xbf, 0xfd, 0x5f, 0xff, 0x80, 0x0, 0x0, + 0xe, 0xff, 0xf1, 0x0, 0x0, 0x2f, 0xff, 0xe0, + 0x0, 0x0, 0xf, 0xff, 0x91, 0xff, 0xfc, 0x0, + 0x0, 0x3, 0xff, 0xfb, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x30, 0x0, 0x4, 0xff, 0xf5, 0xd, 0xff, + 0xf1, 0x0, 0x0, 0x8f, 0xff, 0x60, 0x0, 0x0, + 0x9, 0xff, 0xf7, 0x0, 0x0, 0x8f, 0xff, 0x10, + 0x9f, 0xff, 0x50, 0x0, 0xd, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xc0, 0x0, 0xd, 0xff, + 0xc0, 0x5, 0xff, 0xf9, 0x0, 0x1, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x0, 0x1, + 0xff, 0xf8, 0x0, 0x1f, 0xff, 0xd0, 0x0, 0x6f, + 0xff, 0x70, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf4, + 0x0, 0x5f, 0xff, 0x40, 0x0, 0xdf, 0xff, 0x10, + 0xb, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0x90, 0xa, 0xff, 0xf0, 0x0, 0x8, 0xff, + 0xf5, 0x0, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xfd, 0x0, 0xef, 0xfb, 0x0, 0x0, + 0x4f, 0xff, 0x90, 0x4f, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf2, 0x2f, 0xff, 0x70, + 0x0, 0x0, 0xff, 0xfd, 0x9, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x66, 0xff, + 0xf3, 0x0, 0x0, 0xc, 0xff, 0xf2, 0xef, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfa, + 0xaf, 0xff, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x9f, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xee, 0xff, 0xb0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + + /* U+0078 "x" */ + 0x9, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xa0, 0x0, 0xdf, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfd, 0x0, + 0x0, 0x3f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xf3, 0x0, 0x0, 0x8, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x8, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xf4, 0x0, 0x0, 0x4f, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xfd, 0x0, 0x1, 0xef, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0x80, 0xa, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf3, 0x5f, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xfc, 0xef, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xfc, 0xcf, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf2, 0x2f, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0x60, 0x7, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xfc, 0x0, 0x0, 0xcf, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xf2, 0x0, 0x0, 0x2f, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x70, 0x0, 0x0, 0x7, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x3f, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf3, 0x0, + 0x0, 0xdf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xfd, 0x0, 0x9, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x90, + 0x4f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xf4, + + /* U+0079 "y" */ + 0x1f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf6, 0xa, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf0, + 0x4, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xa0, 0x0, 0xef, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x40, + 0x0, 0x8f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xfe, 0x0, 0x0, 0x2f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf8, 0x0, + 0x0, 0xc, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf2, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xd0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xb0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xf1, 0x0, 0x0, 0x6, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xf6, 0x0, 0x0, 0xc, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xfc, 0x0, 0x0, 0x2f, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x10, 0x0, 0x8f, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0x70, 0x0, 0xdf, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xc0, 0x3, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf2, 0x8, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xf7, 0xe, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xfc, 0x2f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0x7f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6d, 0xbb, 0xef, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xe4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x57, 0x64, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+007A "z" */ + 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x30, 0x2f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x2, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x30, 0x6, 0x66, 0x66, 0x66, 0x66, + 0x66, 0x66, 0x6b, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xef, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2e, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xfb, 0x99, 0xaa, 0xbb, + 0xbb, 0xbb, 0xbb, 0xbb, 0xba, 0x1f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, + + /* U+007B "{" */ + 0x0, 0x0, 0x0, 0x0, 0x1, 0x57, 0x77, 0x0, + 0x0, 0x0, 0x2, 0xbf, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x2e, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xc7, 0x44, 0x0, 0x0, 0x5, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x1, 0x6f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xd4, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xe6, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x1, 0x6e, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xb6, 0x43, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x2, 0xcf, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x2, 0x57, + 0x77, + + /* U+007C "|" */ + 0x9f, 0xff, 0x19, 0xff, 0xf1, 0x9f, 0xff, 0x19, + 0xff, 0xf1, 0x9f, 0xff, 0x19, 0xff, 0xf1, 0x9f, + 0xff, 0x19, 0xff, 0xf1, 0x9f, 0xff, 0x19, 0xff, + 0xf1, 0x9f, 0xff, 0x19, 0xff, 0xf1, 0x9f, 0xff, + 0x19, 0xff, 0xf1, 0x9f, 0xff, 0x19, 0xff, 0xf1, + 0x9f, 0xff, 0x19, 0xff, 0xf1, 0x9f, 0xff, 0x19, + 0xff, 0xf1, 0x9f, 0xff, 0x19, 0xff, 0xf1, 0x9f, + 0xff, 0x19, 0xff, 0xf1, 0x9f, 0xff, 0x19, 0xff, + 0xf1, 0x9f, 0xff, 0x19, 0xff, 0xf1, 0x9f, 0xff, + 0x19, 0xff, 0xf1, 0x9f, 0xff, 0x19, 0xff, 0xf1, + 0x9f, 0xff, 0x19, 0xff, 0xf1, 0x9f, 0xff, 0x19, + 0xff, 0xf1, 0x9f, 0xff, 0x19, 0xff, 0xf1, 0x9f, + 0xff, 0x19, 0xff, 0xf1, 0x9f, 0xff, 0x19, 0xff, + 0xf1, 0x9f, 0xff, 0x19, 0xff, 0xf1, 0x9f, 0xff, + 0x19, 0xff, 0xf1, + + /* U+007D "}" */ + 0x77, 0x75, 0x20, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xfc, 0x20, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0xd1, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x34, 0x6c, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xf7, 0x20, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x4d, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x4d, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xe6, 0x10, 0x0, 0x0, 0x1, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x60, 0x0, 0x0, 0x34, 0x6c, + 0xff, 0xff, 0x30, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xfc, 0x30, 0x0, + 0x0, 0x0, 0x77, 0x75, 0x20, 0x0, 0x0, 0x0, + 0x0, + + /* U+007E "~" */ + 0x0, 0x0, 0x46, 0x76, 0x41, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0x0, 0x19, 0xff, 0xff, + 0xff, 0xfc, 0x71, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xf0, 0x4e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0x50, 0x0, 0x0, 0x19, 0xff, 0xe, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x89, 0xbf, + 0xff, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf, 0xff, + 0x93, 0x10, 0x26, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd0, 0xfc, 0x20, 0x0, 0x0, 0x0, + 0x18, 0xef, 0xff, 0xff, 0xff, 0xff, 0x90, 0xa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x48, 0xce, + 0xfe, 0xc8, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+00A0 " " */ + + /* U+00A3 "£" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x57, 0x76, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x29, 0xff, 0xff, 0xff, 0xff, 0xb3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xf8, 0x31, 0x13, 0x8f, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfd, 0x20, 0x0, + 0x0, 0x2, 0xdf, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xfc, 0x0, 0x0, 0x1, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x20, + 0x0, 0x4, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0x50, 0x0, 0x6, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbe, + 0xb9, 0x30, 0x0, 0x6, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0x88, 0xbf, 0xff, 0xfa, 0x88, 0x88, 0x88, + 0x60, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xdf, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xcf, 0xff, 0xdc, 0xef, + 0xfe, 0xc9, 0x63, 0x0, 0x0, 0x0, 0x28, 0x20, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0xba, 0xbe, 0xff, 0x80, 0xd, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe0, 0x7, 0xff, 0xff, 0xeb, 0x98, 0x9c, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x1, + 0xfe, 0x82, 0x0, 0x0, 0x0, 0x3, 0x7b, 0xff, + 0xff, 0xff, 0xfd, 0x71, 0x0, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0x67, 0x75, 0x10, + 0x0, + + /* U+00A4 "¤" */ + 0x0, 0x5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x13, 0x0, 0x0, 0x8f, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, 0x30, + 0x7, 0xff, 0xf9, 0x0, 0x39, 0xce, 0xfe, 0xb7, + 0x10, 0x1d, 0xff, 0xf3, 0xd, 0xff, 0xff, 0x9a, + 0xff, 0xff, 0xff, 0xff, 0xf8, 0xcf, 0xff, 0xf8, + 0x1, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x1c, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xfa, 0x30, 0x1, 0x5d, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf2, 0x0, + 0x0, 0xe, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf9, 0x0, 0x0, 0x3f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xfe, 0x0, + 0x0, 0x7f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x20, 0x0, 0x8f, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x30, + 0x0, 0x8f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0x30, 0x0, 0x7f, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x20, + 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xfe, 0x0, 0x0, 0xe, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf9, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xf2, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xf9, 0x30, 0x0, 0x5d, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x1d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf9, 0x0, 0x1, 0xdf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, + 0xd, 0xff, 0xff, 0x9a, 0xff, 0xff, 0xff, 0xff, + 0xf7, 0xcf, 0xff, 0xf8, 0x7, 0xff, 0xf9, 0x0, + 0x39, 0xcf, 0xfe, 0xb7, 0x10, 0x1d, 0xff, 0xf3, + 0x0, 0x8f, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xdf, 0x30, 0x0, 0x5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x14, 0x0, + + /* U+00A5 "¥" */ + 0xbf, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0x52, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xc0, 0x9, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf4, + 0x0, 0x1e, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xfb, 0x0, 0x0, 0x7f, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0x20, 0x0, 0x0, 0xdf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x5, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0xd, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xe0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0x80, 0x0, 0x0, 0xef, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0x10, 0x0, 0x7f, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf9, + 0x0, 0xe, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf2, 0x8, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x91, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0x9f, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x20, 0x7, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x20, 0x3, 0x88, + 0x88, 0x88, 0x88, 0x8d, 0xff, 0xfc, 0x88, 0x88, + 0x88, 0x88, 0x81, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf2, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x20, 0x7, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x25, 0x55, 0x55, + 0x55, 0x55, 0xcf, 0xff, 0xa5, 0x55, 0x55, 0x55, + 0x55, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+00A6 "¦" */ + 0x9f, 0xff, 0x19, 0xff, 0xf1, 0x9f, 0xff, 0x19, + 0xff, 0xf1, 0x9f, 0xff, 0x19, 0xff, 0xf1, 0x9f, + 0xff, 0x19, 0xff, 0xf1, 0x9f, 0xff, 0x19, 0xff, + 0xf1, 0x9f, 0xff, 0x19, 0xff, 0xf1, 0x9f, 0xff, + 0x19, 0xff, 0xf1, 0x9f, 0xff, 0x19, 0xff, 0xf1, + 0x9f, 0xff, 0x19, 0xff, 0xf1, 0x8e, 0xee, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xf1, 0x9f, 0xff, + 0x19, 0xff, 0xf1, 0x9f, 0xff, 0x19, 0xff, 0xf1, + 0x9f, 0xff, 0x19, 0xff, 0xf1, 0x9f, 0xff, 0x19, + 0xff, 0xf1, 0x9f, 0xff, 0x19, 0xff, 0xf1, 0x9f, + 0xff, 0x19, 0xff, 0xf1, 0x9f, 0xff, 0x19, 0xff, + 0xf1, 0x9f, 0xff, 0x19, 0xff, 0xf1, 0x9f, 0xff, + 0x19, 0xff, 0xf1, + + /* U+00A7 "§" */ + 0x0, 0x0, 0x0, 0x0, 0x36, 0x77, 0x63, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x18, 0xff, + 0xff, 0xff, 0xff, 0xa3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xb4, 0x11, 0x39, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x8f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x10, + 0x0, 0xb, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf5, 0x0, 0x0, 0xbf, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xfe, 0x60, 0x0, + 0x8, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x20, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0xfc, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xbf, 0xff, 0xff, 0xff, 0xc2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xdf, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xfe, 0x30, 0x8f, 0xff, 0xff, 0xfd, + 0x30, 0x0, 0x0, 0x2, 0xff, 0xfe, 0x20, 0x0, + 0x4e, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x9f, + 0xff, 0x50, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xc1, 0x0, 0xd, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x3, 0xdf, 0xff, 0xff, 0xe2, 0x0, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xe1, 0xf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xa0, 0xcf, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, 0xff, + 0x28, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf6, 0x1f, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x80, + 0x6f, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xf9, 0x0, 0x8f, 0xff, 0xff, 0xe5, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x70, 0x0, + 0x6f, 0xff, 0xff, 0xfb, 0x20, 0x0, 0x0, 0xc, + 0xff, 0xf3, 0x0, 0x0, 0x3e, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x7, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x1a, 0xff, 0xff, 0xff, 0xc2, 0x8, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x4, 0xef, 0xff, 0xff, + 0xfd, 0xff, 0xfb, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0xd5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3d, 0xff, 0xff, + 0xfc, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xef, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xef, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xa0, 0x0, 0x14, 0x79, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xfd, 0x0, 0x6, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf0, + 0x0, 0x3f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xfe, 0x0, 0x0, 0xef, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xb0, 0x0, + 0x8, 0xff, 0xff, 0xb1, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xf6, 0x0, 0x0, 0xd, 0xff, 0xff, 0xe7, + 0x32, 0x36, 0xcf, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x20, 0x0, 0x0, 0x0, 0x2d, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xdf, 0xff, 0xff, 0xff, 0xe7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x15, 0x67, 0x75, + 0x20, 0x0, 0x0, 0x0, 0x0, + + /* U+00A8 "¨" */ + 0x8e, 0xee, 0xc0, 0x0, 0xc, 0xee, 0xe8, 0x9f, + 0xff, 0xd0, 0x0, 0xd, 0xff, 0xf9, 0x9f, 0xff, + 0xd0, 0x0, 0xd, 0xff, 0xf9, 0x9f, 0xff, 0xd0, + 0x0, 0xd, 0xff, 0xf9, 0x9f, 0xff, 0xd0, 0x0, + 0xd, 0xff, 0xf9, + + /* U+00A9 "©" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x27, 0xad, + 0xef, 0xfe, 0xc9, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6c, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x91, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1a, 0xff, 0xff, 0xe9, 0x52, 0x0, 0x2, + 0x48, 0xdf, 0xff, 0xfe, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xdf, 0xff, 0xd5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xbf, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xef, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1c, 0xff, 0xf4, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfe, 0x10, 0x0, + 0x0, 0x4f, 0xff, 0x40, 0x0, 0x0, 0x2, 0x7b, + 0xef, 0xfd, 0xa5, 0x0, 0x0, 0x0, 0x1d, 0xff, + 0xb0, 0x0, 0x0, 0xdf, 0xf8, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xd3, 0x0, 0x0, + 0x3, 0xff, 0xf4, 0x0, 0x5, 0xff, 0xd0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xdb, 0xce, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x9f, 0xfc, 0x0, 0xc, 0xff, + 0x50, 0x0, 0x0, 0xaf, 0xff, 0x91, 0x0, 0x0, + 0x4d, 0xff, 0xe0, 0x0, 0x0, 0x1f, 0xff, 0x30, + 0x1f, 0xfe, 0x0, 0x0, 0x5, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x1, 0xdf, 0xf8, 0x0, 0x0, 0x9, + 0xff, 0x80, 0x6f, 0xf9, 0x0, 0x0, 0xc, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xe8, 0x0, + 0x0, 0x4, 0xff, 0xd0, 0xaf, 0xf5, 0x0, 0x0, + 0x1f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf0, 0xdf, 0xf2, + 0x0, 0x0, 0x5f, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xf3, + 0xef, 0xf0, 0x0, 0x0, 0x7f, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xf4, 0xff, 0xf0, 0x0, 0x0, 0x8f, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf5, 0xff, 0xf0, 0x0, 0x0, + 0x8f, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf5, 0xef, 0xf0, + 0x0, 0x0, 0x7f, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf4, + 0xdf, 0xf2, 0x0, 0x0, 0x4f, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xf3, 0xaf, 0xf5, 0x0, 0x0, 0x1f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0xe, 0xfa, 0x10, + 0x0, 0x0, 0xff, 0xf0, 0x7f, 0xf9, 0x0, 0x0, + 0xb, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xfe, 0x0, 0x0, 0x3, 0xff, 0xd0, 0x3f, 0xfe, + 0x0, 0x0, 0x4, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf8, 0x0, 0x0, 0x8, 0xff, 0x80, + 0xd, 0xff, 0x50, 0x0, 0x0, 0x9f, 0xff, 0xa2, + 0x0, 0x1, 0x8f, 0xff, 0xd0, 0x0, 0x0, 0xe, + 0xff, 0x30, 0x6, 0xff, 0xd0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xed, 0xef, 0xff, 0xfe, 0x20, 0x0, + 0x0, 0x8f, 0xfc, 0x0, 0x0, 0xef, 0xf8, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xb1, + 0x0, 0x0, 0x2, 0xff, 0xf4, 0x0, 0x0, 0x5f, + 0xff, 0x40, 0x0, 0x0, 0x2, 0x8c, 0xef, 0xfd, + 0x93, 0x0, 0x0, 0x0, 0xd, 0xff, 0xb0, 0x0, + 0x0, 0xb, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfe, + 0x10, 0x0, 0x0, 0x1, 0xdf, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1c, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xef, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xdf, 0xff, 0xd5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xaf, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1b, 0xff, 0xff, 0xe9, 0x52, + 0x0, 0x1, 0x47, 0xcf, 0xff, 0xfe, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6e, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x91, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x7e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xa2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x38, 0xbd, 0xff, 0xfe, + 0xc9, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00AA "ª" */ + 0x0, 0x0, 0x29, 0xdf, 0xec, 0x70, 0x3, 0xff, + 0xf2, 0x0, 0x6, 0xff, 0xff, 0xff, 0xfd, 0x27, + 0xff, 0xd0, 0x0, 0x6f, 0xff, 0xfb, 0xad, 0xff, + 0xed, 0xff, 0x90, 0x1, 0xff, 0xfe, 0x30, 0x0, + 0x6f, 0xff, 0xff, 0x50, 0x8, 0xff, 0xf5, 0x0, + 0x0, 0x9, 0xff, 0xff, 0x20, 0xd, 0xff, 0xd0, + 0x0, 0x0, 0x1, 0xff, 0xfe, 0x0, 0xf, 0xff, + 0x90, 0x0, 0x0, 0x0, 0xdf, 0xfb, 0x0, 0x2f, + 0xff, 0x60, 0x0, 0x0, 0x0, 0xaf, 0xf8, 0x0, + 0x3f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x9f, 0xf5, + 0x0, 0x3f, 0xff, 0x50, 0x0, 0x0, 0x0, 0xaf, + 0xf5, 0x0, 0x2f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0xbf, 0xf8, 0x0, 0xf, 0xff, 0x90, 0x0, 0x0, + 0x0, 0xef, 0xfc, 0x0, 0xc, 0xff, 0xd0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x0, 0x7, 0xff, 0xf4, + 0x0, 0x0, 0xb, 0xff, 0xff, 0x40, 0x1, 0xef, + 0xfe, 0x20, 0x0, 0x8f, 0xff, 0xff, 0x80, 0x0, + 0x5f, 0xff, 0xfb, 0xae, 0xff, 0xec, 0xff, 0xe0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xfe, 0x32, 0xbb, + 0xb2, 0x0, 0x0, 0x29, 0xdf, 0xed, 0x81, 0x0, + 0x0, 0x0, + + /* U+00AB "«" */ + 0x0, 0x0, 0x0, 0x7, 0xdd, 0xc0, 0x0, 0x0, + 0x7d, 0xdd, 0x10, 0x0, 0x0, 0x3, 0xff, 0xf6, + 0x0, 0x0, 0x2f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0xdf, 0xfd, 0x0, 0x0, 0xc, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x40, 0x0, 0x7, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xb0, 0x0, + 0x2, 0xff, 0xfd, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xf3, 0x0, 0x0, 0xcf, 0xff, 0x40, 0x0, 0x0, + 0xa, 0xff, 0xfa, 0x0, 0x0, 0x8f, 0xff, 0xb0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0x10, 0x0, 0x3f, + 0xff, 0xf2, 0x0, 0x0, 0x1, 0xef, 0xff, 0x80, + 0x0, 0xd, 0xff, 0xf9, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xe0, 0x0, 0x8, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x5f, 0xff, 0xf6, 0x0, 0x3, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x7, 0xff, 0xff, 0x40, 0x0, + 0x4f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xfd, 0x0, 0x0, 0xaf, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0xef, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xe0, 0x0, + 0x4, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x80, 0x0, 0x9, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0x10, 0x0, 0xe, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfa, 0x0, + 0x0, 0x4f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf3, 0x0, 0x0, 0x9f, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xb0, 0x0, 0x0, 0xdf, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x40, + 0x0, 0x4, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xfd, 0x0, 0x0, 0x9, 0xff, 0xf1, + + /* U+00AC "¬" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf5, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0x88, 0x82, + + /* U+00AD "­" */ + 0x25, 0x55, 0x55, 0x55, 0x55, 0x55, 0x52, 0x7f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf7, 0x7f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf7, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf7, + + /* U+00AE "®" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x27, 0xad, + 0xef, 0xfe, 0xc9, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6c, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x91, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1a, 0xff, 0xff, 0xe9, 0x52, 0x0, 0x2, + 0x48, 0xdf, 0xff, 0xfe, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xdf, 0xff, 0xd5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xbf, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xef, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1c, 0xff, 0xf4, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfe, 0x10, 0x0, + 0x0, 0x4f, 0xff, 0x40, 0x0, 0xaa, 0xaa, 0xaa, + 0xa9, 0x97, 0x50, 0x0, 0x0, 0x0, 0x1d, 0xff, + 0xb0, 0x0, 0x0, 0xdf, 0xf8, 0x0, 0x1, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0x60, 0x0, 0x0, + 0x3, 0xff, 0xf4, 0x0, 0x5, 0xff, 0xd0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x9f, 0xfc, 0x0, 0xc, 0xff, + 0x50, 0x0, 0x1, 0xff, 0xf0, 0x0, 0x0, 0x26, + 0xdf, 0xff, 0x10, 0x0, 0x0, 0x1f, 0xff, 0x30, + 0x1f, 0xfe, 0x0, 0x0, 0x1, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0x70, 0x0, 0x0, 0x9, + 0xff, 0x80, 0x6f, 0xf9, 0x0, 0x0, 0x1, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0xb, 0xff, 0x90, 0x0, + 0x0, 0x4, 0xff, 0xd0, 0xaf, 0xf5, 0x0, 0x0, + 0x1, 0xff, 0xf0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0x80, 0x0, 0x0, 0x0, 0xff, 0xf0, 0xdf, 0xf2, + 0x0, 0x0, 0x1, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x40, 0x0, 0x0, 0x0, 0xcf, 0xf3, + 0xef, 0xf0, 0x0, 0x0, 0x1, 0xff, 0xf0, 0x0, + 0x0, 0x26, 0xef, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xf4, 0xff, 0xf0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xe2, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xf5, 0xff, 0xf0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xf5, 0xef, 0xf0, + 0x0, 0x0, 0x1, 0xff, 0xfb, 0xbc, 0xff, 0xfc, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf4, + 0xdf, 0xf2, 0x0, 0x0, 0x1, 0xff, 0xf0, 0x0, + 0x9, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xf3, 0xaf, 0xf5, 0x0, 0x0, 0x1, 0xff, + 0xf0, 0x0, 0x0, 0xaf, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xf0, 0x7f, 0xf9, 0x0, 0x0, + 0x1, 0xff, 0xf0, 0x0, 0x0, 0xe, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xd0, 0x3f, 0xfe, + 0x0, 0x0, 0x1, 0xff, 0xf0, 0x0, 0x0, 0x4, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x8, 0xff, 0x80, + 0xd, 0xff, 0x50, 0x0, 0x1, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0xbf, 0xfd, 0x0, 0x0, 0x0, 0xe, + 0xff, 0x30, 0x6, 0xff, 0xd0, 0x0, 0x1, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x70, 0x0, + 0x0, 0x8f, 0xfc, 0x0, 0x0, 0xef, 0xf8, 0x0, + 0x1, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf1, 0x0, 0x2, 0xff, 0xf4, 0x0, 0x0, 0x5f, + 0xff, 0x40, 0x0, 0xee, 0xe0, 0x0, 0x0, 0x0, + 0x1, 0xee, 0xe9, 0x0, 0xd, 0xff, 0xb0, 0x0, + 0x0, 0xb, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfe, + 0x10, 0x0, 0x0, 0x1, 0xdf, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1c, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xef, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xdf, 0xff, 0xd5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xaf, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1b, 0xff, 0xff, 0xe9, 0x52, + 0x0, 0x1, 0x47, 0xcf, 0xff, 0xfe, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6e, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x91, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x7e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xa2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x38, 0xbd, 0xff, 0xfe, + 0xc9, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00B0 "°" */ + 0x0, 0x3, 0xae, 0xfe, 0xb4, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x7, 0xff, + 0xfc, 0x9b, 0xff, 0xfb, 0x0, 0x2f, 0xfe, 0x30, + 0x0, 0x2d, 0xff, 0x50, 0x9f, 0xf3, 0x0, 0x0, + 0x1, 0xff, 0xc0, 0xcf, 0xc0, 0x0, 0x0, 0x0, + 0x9f, 0xf0, 0xef, 0xa0, 0x0, 0x0, 0x0, 0x7f, + 0xf1, 0xdf, 0xc0, 0x0, 0x0, 0x0, 0x9f, 0xf0, + 0x9f, 0xf3, 0x0, 0x0, 0x1, 0xff, 0xc0, 0x2f, + 0xfe, 0x30, 0x0, 0x2d, 0xff, 0x50, 0x7, 0xff, + 0xfc, 0xab, 0xff, 0xfb, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x3, 0xae, 0xfe, + 0xb4, 0x0, 0x0, + + /* U+00B1 "±" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x33, 0x33, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf5, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf5, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf5, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf5, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + + /* U+00B2 "²" */ + 0x0, 0x0, 0x4a, 0xdf, 0xfe, 0xc8, 0x20, 0x0, + 0x0, 0x1b, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0xcf, 0xff, 0xfd, 0xcf, 0xff, 0xff, 0x50, + 0x5, 0xff, 0xfa, 0x10, 0x0, 0x7f, 0xff, 0xd0, + 0xc, 0xff, 0xe0, 0x0, 0x0, 0xc, 0xff, 0xf0, + 0x2, 0x46, 0x50, 0x0, 0x0, 0xa, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xdf, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x10, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xfd, 0x20, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xc1, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xdd, 0xdd, 0xdd, 0xdd, 0xd2, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + + /* U+00B3 "³" */ + 0x0, 0x0, 0x6b, 0xef, 0xfe, 0xb6, 0x0, 0x0, + 0x0, 0x2d, 0xff, 0xff, 0xff, 0xff, 0xe3, 0x0, + 0x0, 0xdf, 0xff, 0xda, 0xae, 0xff, 0xfd, 0x0, + 0x6, 0xff, 0xf7, 0x0, 0x0, 0xcf, 0xff, 0x30, + 0x5, 0xac, 0xb0, 0x0, 0x0, 0x6f, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x28, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfe, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x48, 0xac, 0xff, 0xfc, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf0, + 0x1, 0x35, 0x10, 0x0, 0x0, 0x8, 0xff, 0xf1, + 0x1f, 0xff, 0x90, 0x0, 0x0, 0xd, 0xff, 0xf0, + 0xb, 0xff, 0xf7, 0x0, 0x1, 0xbf, 0xff, 0xb0, + 0x2, 0xff, 0xff, 0xec, 0xdf, 0xff, 0xff, 0x20, + 0x0, 0x4e, 0xff, 0xff, 0xff, 0xff, 0xd3, 0x0, + 0x0, 0x0, 0x6b, 0xef, 0xfe, 0xb6, 0x0, 0x0, + + /* U+00B5 "µ" */ + 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x6b, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf6, 0xbf, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x6b, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf6, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x6b, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf6, 0xbf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x6b, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf6, 0xbf, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x6b, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf6, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x6b, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf6, 0xbf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x6b, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf6, 0xbf, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x6b, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf6, + 0xbf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0x6b, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf6, 0xbf, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x6b, + 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xf6, 0xbf, 0xff, 0xff, 0xc2, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0x6b, 0xff, 0xff, 0xff, + 0xfa, 0x76, 0x8d, 0xff, 0xff, 0xff, 0xf6, 0xbf, + 0xff, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9f, + 0xff, 0x6b, 0xff, 0xf7, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0x66, 0xff, 0xf6, 0xbf, 0xff, 0x70, 0x5e, + 0xff, 0xff, 0xfc, 0x30, 0x6f, 0xff, 0x6b, 0xff, + 0xf7, 0x0, 0x4, 0x67, 0x52, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00B6 "¶" */ + 0x0, 0x0, 0x0, 0x5, 0x9d, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x0, 0x1, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x0, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x52, 0x22, 0x29, + 0xff, 0xf8, 0x22, 0x10, 0x2f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x8f, 0xff, 0x70, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x8, 0xff, 0xf7, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x8f, 0xff, 0x70, 0x0, 0xf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x8, 0xff, 0xf7, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x8f, 0xff, 0x70, 0x0, 0x1f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x8, 0xff, 0xf7, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x8f, 0xff, + 0x70, 0x0, 0xd, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x8, 0xff, 0xf7, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x8f, 0xff, 0x70, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, 0x8, 0xff, + 0xf7, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x8f, 0xff, 0x70, 0x0, + 0x0, 0x1e, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x8, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x2d, + 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x8f, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x19, 0xff, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x8, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x69, 0xbe, 0xff, 0xf4, + 0x0, 0x0, 0x8f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0x40, 0x0, 0x8, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf4, 0x0, 0x0, 0x8f, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x40, 0x0, 0x8, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf4, 0x0, 0x0, + 0x8f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0x40, 0x0, 0x8, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf4, 0x0, 0x0, 0x8f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x40, 0x0, + 0x8, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf4, 0x0, 0x0, 0x8f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0x40, 0x0, 0x8, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf4, 0x0, + 0x0, 0x8f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x40, 0x0, 0x8, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf4, 0x0, 0x0, 0x8f, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x40, + 0x0, 0x8, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xf4, 0x0, 0x0, 0x8f, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x40, 0x0, 0x8, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf4, + 0x0, 0x0, 0x8f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0x40, 0x0, 0x8, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf4, 0x0, 0x0, 0x8f, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x40, 0x0, 0x8, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf4, 0x0, 0x0, + 0x8f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0x40, 0x0, 0x8, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf4, 0x0, 0x0, 0x8f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x40, 0x0, + 0x8, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf4, 0x0, 0x0, 0x8f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0x40, 0x0, 0x8, 0xff, 0xf7, 0x0, 0x0, + + /* U+00B7 "·" */ + 0xae, 0xee, 0xe1, 0xbf, 0xff, 0xf2, 0xbf, 0xff, + 0xf2, 0xbf, 0xff, 0xf2, 0xbf, 0xff, 0xf2, + + /* U+00BB "»" */ + 0x5d, 0xdd, 0x20, 0x0, 0x3, 0xdd, 0xd3, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xfc, 0x0, 0x0, 0xb, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf8, + 0x0, 0x0, 0x2f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf3, 0x0, 0x0, 0x9f, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xd0, 0x0, 0x1, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0x80, 0x0, 0x7, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0x30, 0x0, 0xe, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xfd, 0x0, 0x0, + 0x5f, 0xff, 0xe1, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xf8, 0x0, 0x0, 0xcf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf3, 0x0, 0x3, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xd0, 0x0, + 0xa, 0xff, 0xff, 0x20, 0x0, 0x0, 0xa, 0xff, + 0xfe, 0x10, 0x0, 0x9f, 0xff, 0xf3, 0x0, 0x0, + 0x3, 0xff, 0xff, 0x50, 0x0, 0x2f, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xa0, 0x0, 0xb, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xe1, + 0x0, 0x4, 0xff, 0xff, 0x20, 0x0, 0x0, 0xe, + 0xff, 0xf4, 0x0, 0x0, 0xdf, 0xff, 0x60, 0x0, + 0x0, 0x8, 0xff, 0xfa, 0x0, 0x0, 0x6f, 0xff, + 0xb0, 0x0, 0x0, 0x1, 0xff, 0xfe, 0x10, 0x0, + 0xe, 0xff, 0xf1, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x40, 0x0, 0x8, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x90, 0x0, 0x1, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xe0, 0x0, 0x0, 0x9f, + 0xfe, 0x10, 0x0, 0x0, 0x5, 0xff, 0xf4, 0x0, + 0x0, 0x2f, 0xff, 0x50, 0x0, 0x0, 0x0, + + /* U+00BD "½" */ + 0x0, 0x0, 0x0, 0x12, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x22, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x1c, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xef, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0x40, 0x0, 0x0, 0x0, 0x4e, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xa4, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xb3, 0x3, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x21, 0x0, 0x3, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xfb, 0x0, 0x0, 0x0, 0x4a, 0xdf, + 0xfe, 0xc9, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xe1, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x40, 0x0, 0x0, 0xbf, 0xff, 0xfe, 0xef, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf9, 0x0, 0x0, 0x5, 0xff, 0xfb, + 0x20, 0x0, 0x8f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xd0, 0x0, 0x0, + 0xb, 0xff, 0xf1, 0x0, 0x0, 0xc, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0x30, 0x0, 0x0, 0x3, 0x57, 0x60, 0x0, 0x0, + 0xa, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xcf, 0xff, 0xd1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4e, 0xff, 0xfc, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xfd, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xee, 0xee, 0xee, 0xee, + 0xe2, 0x0, 0x0, 0x4f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf3, 0x0, 0x1, 0xef, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0x3, 0x88, 0x81, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0384 "΄" */ + 0x0, 0x9, 0xbb, 0xbb, 0x60, 0x3, 0xff, 0xff, + 0xd1, 0x0, 0xbf, 0xff, 0xf3, 0x0, 0x2f, 0xff, + 0xf6, 0x0, 0xa, 0xff, 0xfa, 0x0, 0x1, 0xff, + 0xfd, 0x0, 0x0, 0x9f, 0xff, 0x20, 0x0, 0x0, + + /* U+0386 "Ά" */ + 0x0, 0x0, 0xd, 0xff, 0xff, 0x80, 0x0, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfc, 0x0, 0x6, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xe1, 0x0, + 0xc, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x30, + 0x0, 0x2f, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, + 0x0, 0x0, 0x8f, 0xff, 0x8f, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xb0, 0x0, 0x0, 0xef, 0xff, 0x1e, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6b, + 0xba, 0x0, 0x0, 0x4, 0xff, 0xfd, 0x9, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf8, 0x3, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf3, + 0x0, 0xef, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xe0, 0x0, 0x8f, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x80, 0x0, 0x2f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0x20, 0x0, 0xc, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xfc, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf6, 0x0, 0x0, 0x0, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xfc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xef, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0x80, 0x0, 0x0, 0xe, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x5f, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf5, 0x0, 0x0, + 0xbf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xfb, 0x0, + 0x1, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0x20, 0x7, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x80, 0xd, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xe0, + + /* U+0388 "Έ" */ + 0x0, 0x3, 0xff, 0xff, 0xf3, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0xaf, 0xff, 0xf6, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x2f, 0xff, 0xfa, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf4, 0x0, 0x9, 0xff, 0xfd, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, 0x1, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x9f, 0xff, 0xf2, 0x22, + 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x20, 0x0, 0x8f, 0xff, 0x50, 0x0, 0x0, 0x9, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xbb, 0x70, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xf1, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, + 0x11, 0x11, 0x11, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xf2, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x22, 0x22, 0x22, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x0, + + /* U+0389 "Ή" */ + 0x0, 0x2, 0xff, 0xff, 0xf3, 0x9, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x60, 0x0, 0xaf, 0xff, 0xf7, + 0x0, 0x9f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf6, 0x0, + 0x1f, 0xff, 0xfa, 0x0, 0x9, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0x60, 0x9, 0xff, 0xfd, 0x0, 0x0, + 0x9f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf6, 0x1, 0xff, + 0xff, 0x20, 0x0, 0x9, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x60, 0x8f, 0xff, 0x50, 0x0, 0x0, 0x9f, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xf6, 0xa, 0xbb, 0x70, + 0x0, 0x0, 0x9, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x22, + 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x24, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0x60, + + /* U+038A "Ί" */ + 0x0, 0x2, 0xff, 0xff, 0xf3, 0x9, 0xff, 0xff, + 0x0, 0xa, 0xff, 0xff, 0x70, 0x9, 0xff, 0xff, + 0x0, 0x1f, 0xff, 0xfa, 0x0, 0x9, 0xff, 0xff, + 0x0, 0x9f, 0xff, 0xd0, 0x0, 0x9, 0xff, 0xff, + 0x1, 0xff, 0xff, 0x20, 0x0, 0x9, 0xff, 0xff, + 0x8, 0xff, 0xf5, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xa, 0xbb, 0x70, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + + /* U+038C "Ό" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x36, 0x77, 0x76, 0x41, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x17, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xc7, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0x60, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xfa, 0x0, 0x4, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe3, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xd0, + 0x0, 0x6f, 0xff, 0xff, 0xff, 0xea, 0x98, 0x9b, + 0xef, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x1, + 0xff, 0xff, 0x20, 0x6, 0xff, 0xff, 0xff, 0x93, + 0x0, 0x0, 0x0, 0x3, 0x9f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x8, 0xff, 0xf5, 0x0, 0x4f, 0xff, + 0xff, 0xc2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xdf, 0xff, 0xff, 0x30, 0x0, 0xa, 0xbb, 0x70, + 0x1, 0xef, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf2, 0x0, + 0x0, 0x6, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xf6, 0x0, 0x0, 0x9, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xf9, 0x0, 0x0, 0xb, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xfb, + 0x0, 0x0, 0xd, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xfd, 0x0, 0x0, 0xe, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xfe, 0x0, 0x0, + 0xe, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xfe, 0x0, 0x0, 0xe, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xfe, 0x0, 0x0, 0xd, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfd, 0x0, + 0x0, 0xc, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xfb, 0x0, 0x0, 0x9, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xf9, 0x0, 0x0, 0x6, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf6, + 0x0, 0x0, 0x2, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xb2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xcf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0x82, 0x0, 0x0, + 0x0, 0x2, 0x9f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xff, 0xda, 0x87, 0x9a, 0xdf, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x16, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xc7, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x36, 0x77, 0x76, + 0x41, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+038E "Ύ" */ + 0x0, 0x3, 0xff, 0xff, 0xf3, 0x0, 0xcf, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xf1, 0x0, 0xa, + 0xff, 0xff, 0x60, 0x0, 0x2f, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0x60, 0x0, 0x2f, 0xff, 0xfa, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xfb, 0x0, 0x0, 0x9f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xe1, 0x0, + 0x1, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0x50, 0x0, 0x8, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xfa, 0x0, 0x0, 0xa, 0xbb, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0x30, 0x0, 0x0, 0xa, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x4f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xf6, 0x0, 0x0, 0xef, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xfe, 0x10, 0x8, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x90, 0x2f, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf2, + 0xbf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfd, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+038F "Ώ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x46, 0x77, 0x65, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0x30, + 0x0, 0x1, 0x7d, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0x60, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd4, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xa0, 0x0, 0x3d, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xd0, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xea, 0x98, 0x9c, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf2, + 0x0, 0x3f, 0xff, 0xff, 0xfb, 0x30, 0x0, 0x0, + 0x1, 0x7f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x8, + 0xff, 0xf5, 0x0, 0x1d, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1c, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0xab, 0xb7, 0x0, 0x9, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0x50, 0x0, 0x0, + 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf6, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x1f, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x60, + 0x0, 0x0, 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0x20, 0x0, 0x0, 0x9, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0x60, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfe, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x1, + 0xbf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x12, 0x22, 0x22, 0x28, 0xff, 0xff, 0xa2, 0x0, + 0x0, 0x6, 0xef, 0xff, 0xd2, 0x22, 0x22, 0x21, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, + + /* U+0390 "ΐ" */ + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, + 0x0, 0x0, 0x3f, 0xff, 0xe0, 0x0, 0xbf, 0xfe, + 0x13, 0xff, 0xfd, 0x3f, 0xff, 0xe0, 0x2, 0xff, + 0xf5, 0x3, 0xff, 0xfd, 0x3f, 0xff, 0xe0, 0xa, + 0xff, 0xa0, 0x3, 0xff, 0xfd, 0x3f, 0xff, 0xe0, + 0x1f, 0xfd, 0x0, 0x3, 0xff, 0xfd, 0x19, 0x99, + 0x80, 0x49, 0x93, 0x0, 0x1, 0x99, 0x98, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf7, 0x0, 0x0, 0x0, + + /* U+0391 "Α" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x8f, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x1e, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xfd, 0x9, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf8, 0x3, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf3, + 0x0, 0xdf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xe0, 0x0, 0x7f, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x80, 0x0, 0x2f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0x20, 0x0, 0xc, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xfc, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf6, 0x0, 0x0, 0x0, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xfc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xef, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0x80, 0x0, 0x0, 0xe, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x5f, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf5, 0x0, 0x0, + 0xbf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xfb, 0x0, + 0x1, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0x20, 0x7, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x80, 0xd, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xe0, + + /* U+0392 "Β" */ + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xed, + 0xb8, 0x40, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x10, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x7f, 0xff, + 0xf3, 0x22, 0x22, 0x22, 0x23, 0x46, 0x9d, 0xff, + 0xff, 0xf9, 0x0, 0x7, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf2, + 0x0, 0x7f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0x70, 0x7, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xfa, 0x0, 0x7f, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xc0, 0x7, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfc, 0x0, 0x7f, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xb0, 0x7, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xf7, 0x0, 0x7f, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x10, 0x7, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0x80, 0x0, 0x7f, 0xff, 0xf3, + 0x22, 0x22, 0x22, 0x22, 0x35, 0x8d, 0xff, 0xff, + 0xb0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe6, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x7, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x1, + 0x24, 0x8d, 0xff, 0xff, 0xf9, 0x0, 0x7f, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xf5, 0x7, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xc0, 0x7f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x27, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xf5, 0x7f, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0x77, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf6, 0x7f, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0x57, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf2, 0x7f, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfe, 0x7, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0x70, 0x7f, 0xff, 0xf3, + 0x22, 0x22, 0x22, 0x22, 0x23, 0x59, 0xef, 0xff, + 0xff, 0xd0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe3, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x91, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xdb, 0x85, 0x0, 0x0, 0x0, + 0x0, + + /* U+0393 "Γ" */ + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x52, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x2f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x52, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x2f, 0xff, + 0xf7, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x2, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+0394 "Δ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x8f, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x1e, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xfd, 0xa, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf8, 0x4, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf3, + 0x0, 0xef, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xe0, 0x0, 0x9f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x90, 0x0, 0x3f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0x30, 0x0, 0xd, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xfd, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf8, 0x0, 0x0, 0x1, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0x70, 0x0, 0x0, 0xf, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x5f, + 0xff, 0xf8, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x22, 0x22, 0xdf, 0xff, 0xf4, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x10, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x80, 0xd, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe0, + + /* U+0395 "Ε" */ + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x3, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xa0, 0x3f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x3f, 0xff, + 0xf6, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x22, 0x21, 0x3, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf6, + 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, + 0x11, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x50, 0x3, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf5, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, + 0x3, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf6, + 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x22, 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x73, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf7, 0x3f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x70, + + /* U+0396 "Ζ" */ + 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x2f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf7, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x2, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x22, 0x22, 0x22, 0x27, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xef, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xfe, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x82, 0x22, + 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x2, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf0, 0x2f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x0, + + /* U+0397 "Η" */ + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x2f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x2f, 0xff, 0xf7, 0x22, + 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x2c, + 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfc, + + /* U+0398 "Θ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x57, + 0x77, 0x64, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6b, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x82, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7e, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2d, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0xff, 0xb9, 0x89, 0xad, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xfb, 0x40, 0x0, 0x0, 0x0, 0x28, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x2, + 0xef, 0xff, 0xfe, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1b, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x6f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0xef, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xf3, 0x0, 0x4, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xfa, 0x0, 0xa, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0x0, 0xf, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x50, 0x3f, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x90, 0x6f, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xc0, 0x8f, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xe0, + 0xaf, 0xff, 0xf0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0xbf, 0xff, + 0xf0, 0xbf, 0xff, 0xf0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0xaf, + 0xff, 0xf1, 0xbf, 0xff, 0xf0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x9f, 0xff, 0xf1, 0xbf, 0xff, 0xf0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0xaf, 0xff, 0xf1, 0xaf, 0xff, 0xf0, 0x0, + 0x0, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x20, + 0x0, 0x0, 0xbf, 0xff, 0xf0, 0x9f, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xe0, 0x6f, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xc0, 0x3f, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x90, + 0xe, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x50, 0xa, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0x10, 0x4, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xfa, 0x0, 0x0, 0xdf, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xf3, 0x0, 0x0, 0x5f, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xb0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1a, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xf9, 0x30, 0x0, 0x0, + 0x0, 0x17, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xef, 0xff, 0xff, 0xfe, 0xa9, + 0x78, 0xac, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6e, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5b, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x82, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0x56, 0x77, 0x64, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0399 "Ι" */ + 0x9f, 0xff, 0xf9, 0xff, 0xff, 0x9f, 0xff, 0xf9, + 0xff, 0xff, 0x9f, 0xff, 0xf9, 0xff, 0xff, 0x9f, + 0xff, 0xf9, 0xff, 0xff, 0x9f, 0xff, 0xf9, 0xff, + 0xff, 0x9f, 0xff, 0xf9, 0xff, 0xff, 0x9f, 0xff, + 0xf9, 0xff, 0xff, 0x9f, 0xff, 0xf9, 0xff, 0xff, + 0x9f, 0xff, 0xf9, 0xff, 0xff, 0x9f, 0xff, 0xf9, + 0xff, 0xff, 0x9f, 0xff, 0xf9, 0xff, 0xff, 0x9f, + 0xff, 0xf9, 0xff, 0xff, 0x9f, 0xff, 0xf9, 0xff, + 0xff, 0x9f, 0xff, 0xf9, 0xff, 0xff, 0x9f, 0xff, + 0xf9, 0xff, 0xff, 0x9f, 0xff, 0xf9, 0xff, 0xff, + 0x9f, 0xff, 0xf9, 0xff, 0xff, 0x9f, 0xff, 0xf0, + + /* U+039A "Κ" */ + 0x7f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xfc, 0x7, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xfb, 0x0, 0x7f, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xfb, 0x0, 0x7, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x7f, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x7, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xf1, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0x10, 0x0, 0x3, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xf1, 0x0, 0x3, 0xef, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x10, + 0x2, 0xef, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf1, 0x2, 0xef, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x12, 0xef, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xf3, 0xef, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xef, 0xff, 0xf9, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xff, 0xf7, 0x7, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0xb, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0x80, 0x0, 0x0, 0x7f, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x40, 0x0, 0x7, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xfe, 0x10, 0x0, 0x7f, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xfb, + 0x0, 0x7, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf6, 0x0, + 0x7f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf2, 0x7, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xd0, 0x7f, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x90, + + /* U+039B "Λ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfd, + 0xcf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf8, + 0x8f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf3, + 0x3f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xe0, + 0xe, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x90, + 0x8, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x30, + 0x3, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfd, 0x0, + 0x0, 0xdf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, 0x0, + 0x0, 0x8f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf2, 0x0, + 0x0, 0x2f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xc0, 0x0, + 0x0, 0xd, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x60, 0x0, + 0x0, 0x7, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x1, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x70, 0x0, + 0x0, 0xd, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xd0, 0x0, + 0x0, 0x3f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf3, 0x0, + 0x0, 0xaf, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf9, 0x0, + 0x0, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x0, + 0x6, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x50, + 0xc, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xb0, + 0x2f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf1, + 0x8f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf7, + + /* U+039C "Μ" */ + 0x6f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xf6, 0x6f, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xf6, 0x6f, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xf6, 0x6f, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xf6, 0x6f, 0xff, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xf6, 0x6f, 0xff, 0xfe, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xf6, 0x6f, 0xff, + 0xf9, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xbf, 0xff, 0xf6, 0x6f, + 0xff, 0xf3, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x6f, 0xff, 0xf6, + 0x6f, 0xff, 0xf0, 0xef, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x1f, 0xff, + 0xf6, 0x6f, 0xff, 0xf0, 0x9f, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfb, 0xf, + 0xff, 0xf6, 0x6f, 0xff, 0xf0, 0x3f, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf6, + 0xf, 0xff, 0xf6, 0x6f, 0xff, 0xf0, 0xe, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf1, 0xf, 0xff, 0xf6, 0x6f, 0xff, 0xf0, 0x9, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xb0, 0xf, 0xff, 0xf6, 0x6f, 0xff, 0xf0, + 0x3, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0x50, 0xf, 0xff, 0xf6, 0x6f, 0xff, + 0xf0, 0x0, 0xef, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0x0, 0xf, 0xff, 0xf6, 0x6f, + 0xff, 0xf0, 0x0, 0x9f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xfa, 0x0, 0xf, 0xff, 0xf6, + 0x6f, 0xff, 0xf0, 0x0, 0x3f, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xf5, 0x0, 0xf, 0xff, + 0xf6, 0x6f, 0xff, 0xf0, 0x0, 0xe, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf0, 0x0, 0xf, + 0xff, 0xf6, 0x6f, 0xff, 0xf0, 0x0, 0x9, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0xe, 0xff, 0xa0, 0x0, + 0xf, 0xff, 0xf6, 0x6f, 0xff, 0xf0, 0x0, 0x3, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x40, + 0x0, 0xf, 0xff, 0xf6, 0x6f, 0xff, 0xf0, 0x0, + 0x0, 0xef, 0xff, 0x20, 0x0, 0x0, 0xaf, 0xff, + 0x0, 0x0, 0xf, 0xff, 0xf6, 0x6f, 0xff, 0xf0, + 0x0, 0x0, 0x9f, 0xff, 0x80, 0x0, 0x0, 0xff, + 0xfa, 0x0, 0x0, 0xf, 0xff, 0xf6, 0x6f, 0xff, + 0xf0, 0x0, 0x0, 0x3f, 0xff, 0xd0, 0x0, 0x5, + 0xff, 0xf4, 0x0, 0x0, 0xf, 0xff, 0xf6, 0x6f, + 0xff, 0xf0, 0x0, 0x0, 0xe, 0xff, 0xf2, 0x0, + 0xa, 0xff, 0xe0, 0x0, 0x0, 0xf, 0xff, 0xf6, + 0x6f, 0xff, 0xf0, 0x0, 0x0, 0x9, 0xff, 0xf8, + 0x0, 0xf, 0xff, 0x90, 0x0, 0x0, 0xf, 0xff, + 0xf6, 0x6f, 0xff, 0xf0, 0x0, 0x0, 0x3, 0xff, + 0xfd, 0x0, 0x5f, 0xff, 0x40, 0x0, 0x0, 0xf, + 0xff, 0xf6, 0x6f, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0x20, 0xaf, 0xfe, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf6, 0x6f, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0x70, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf6, 0x6f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xc5, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf6, 0x6f, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xfb, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf6, 0x6f, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf6, 0x6f, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf6, + 0x6f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf6, 0x6f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf6, 0x6f, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf6, + + /* U+039D "Ν" */ + 0x3f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xfe, 0x3f, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xfe, 0x3f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xfe, 0x3f, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfe, + 0x3f, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xfe, 0x3f, 0xff, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xfe, 0x3f, 0xff, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xfe, 0x3f, 0xff, 0xfe, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfe, + 0x3f, 0xff, 0xf5, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xfe, 0x3f, 0xff, + 0xf2, 0x8f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xfe, 0x3f, 0xff, 0xf2, 0xd, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xfe, 0x3f, 0xff, 0xf2, 0x3, 0xff, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfe, + 0x3f, 0xff, 0xf2, 0x0, 0x9f, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xfe, 0x3f, 0xff, + 0xf2, 0x0, 0xd, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xfe, 0x3f, 0xff, 0xf2, 0x0, + 0x4, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xfe, 0x3f, 0xff, 0xf2, 0x0, 0x0, 0x9f, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfe, + 0x3f, 0xff, 0xf2, 0x0, 0x0, 0xe, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x7, 0xff, 0xfe, 0x3f, 0xff, + 0xf2, 0x0, 0x0, 0x4, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x7, 0xff, 0xfe, 0x3f, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xf9, 0x0, 0x0, 0x7, + 0xff, 0xfe, 0x3f, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xff, 0x40, 0x0, 0x7, 0xff, 0xfe, + 0x3f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xe0, 0x0, 0x7, 0xff, 0xfe, 0x3f, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf9, + 0x0, 0x7, 0xff, 0xfe, 0x3f, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0x30, 0x7, + 0xff, 0xfe, 0x3f, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xd0, 0x7, 0xff, 0xfe, + 0x3f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf8, 0x7, 0xff, 0xfe, 0x3f, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0x37, 0xff, 0xfe, 0x3f, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xd8, + 0xff, 0xfe, 0x3f, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfe, 0xff, 0xfe, + 0x3f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0xfe, 0x3f, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xfe, 0x3f, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xfe, 0x3f, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xfe, + 0x3f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xfe, 0x3f, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xfe, 0x3f, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xfe, + + /* U+039E "Ξ" */ + 0xd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf0, 0xd, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x0, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x1, 0x22, + 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x22, 0x22, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x12, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x22, 0x22, 0x22, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x22, 0x22, + 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x22, 0x17, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xa7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfa, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xa0, + + /* U+039F "Ο" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x57, + 0x77, 0x64, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6b, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x82, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7e, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2d, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0xff, 0xb9, 0x89, 0xad, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xfb, 0x40, 0x0, 0x0, 0x0, 0x28, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x2, + 0xef, 0xff, 0xfe, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1b, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x6f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0xef, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xf3, 0x0, 0x4, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xfa, 0x0, 0xa, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0x0, 0xf, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x50, 0x3f, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x90, 0x6f, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xc0, 0x8f, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xe0, + 0xaf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf0, 0xbf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xf1, 0xbf, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xf1, 0xbf, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf1, 0xaf, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf0, 0x9f, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xe0, 0x6f, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xc0, 0x3f, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x90, + 0xe, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x50, 0xa, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0x10, 0x4, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xfa, 0x0, 0x0, 0xdf, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xf3, 0x0, 0x0, 0x5f, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xb0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1a, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xf9, 0x30, 0x0, 0x0, + 0x0, 0x17, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xef, 0xff, 0xff, 0xfe, 0xa9, + 0x78, 0xac, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6e, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5b, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x82, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0x56, 0x77, 0x64, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A0 "Π" */ + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x2f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x2f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x2f, 0xff, 0xf7, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x22, 0x22, 0x2c, 0xff, 0xfc, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfc, 0x2f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfc, + + /* U+03A1 "Ρ" */ + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xec, 0xa8, 0x40, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe6, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x4f, 0xff, + 0xf5, 0x22, 0x22, 0x22, 0x22, 0x22, 0x35, 0x8e, + 0xff, 0xff, 0xf6, 0x4, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1b, 0xff, 0xff, + 0xe0, 0x4f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x54, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf9, 0x4f, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xc4, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xfe, 0x4f, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xe4, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xfd, 0x4f, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xb4, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xf7, 0x4f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, + 0xff, 0xff, 0x24, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5e, 0xff, 0xff, 0xb0, + 0x4f, 0xff, 0xf5, 0x22, 0x22, 0x22, 0x22, 0x23, + 0x58, 0xdf, 0xff, 0xff, 0xf2, 0x4, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb3, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xec, 0x96, + 0x10, 0x0, 0x0, 0x4, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+03A3 "Σ" */ + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x8, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x8, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd0, 0x7f, 0xff, 0xfc, 0x22, 0x22, 0x22, + 0x22, 0x22, 0x22, 0x22, 0x22, 0x21, 0x0, 0xbf, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xdf, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xef, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1d, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xfc, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x22, 0x22, 0x18, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc8, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, + + /* U+03A4 "Τ" */ + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0x22, 0x22, 0x22, 0x22, 0x22, 0x2b, 0xff, 0xfe, + 0x22, 0x22, 0x22, 0x22, 0x22, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+03A5 "Υ" */ + 0x8f, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xf4, + 0xd, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x90, + 0x3, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfe, 0x0, + 0x0, 0x9f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf4, 0x0, + 0x0, 0xd, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x1f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfa, 0x0, + 0x0, 0xbf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0x40, + 0x5, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xd0, + 0xd, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf6, + 0x7f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xfe, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A6 "Φ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0x66, 0x62, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x26, 0x9b, 0xcd, 0xff, + 0xff, 0xec, 0xba, 0x73, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xdf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x81, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3d, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xfb, 0x63, 0x12, 0xff, 0xff, 0x61, + 0x25, 0x9f, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xb2, 0x0, 0x0, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x18, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0xe, 0xff, 0xff, 0x80, 0x0, 0x0, 0x2, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xf5, 0x0, 0x7, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xd0, 0x0, 0xef, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0x50, 0x4f, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfa, 0x9, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xe0, + 0xcf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x1e, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xf3, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0x4f, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf4, 0xef, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x3c, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xf1, 0x9f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xfe, 0x5, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xa0, 0xf, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xf4, 0x0, 0x8f, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xfd, 0x0, 0x0, + 0xef, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x40, + 0x0, 0x4, 0xff, 0xff, 0xfd, 0x40, 0x0, 0x2, + 0xff, 0xff, 0x60, 0x0, 0x1, 0x8f, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xd7, + 0x31, 0x2f, 0xff, 0xf6, 0x12, 0x59, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4c, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x59, 0xac, 0xdf, + 0xff, 0xfe, 0xcb, 0x96, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+03A7 "Χ" */ + 0x0, 0xdf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x60, + 0x0, 0x3f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfa, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfc, 0x0, + 0x0, 0x3f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x70, + 0x1, 0xef, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf2, + 0xa, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xfc, + 0x4f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfb, + 0xdf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xf2, + 0x3f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x70, + 0x9, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfc, 0x0, + 0x0, 0xdf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf4, 0x0, + 0x1, 0xef, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfe, 0x10, + 0xb, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xa0, + 0x6f, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf5, + + /* U+03A8 "Ψ" */ + 0xf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xf2, 0xf, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xf2, 0xf, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf2, 0xf, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf2, + 0xf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xf2, 0xf, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xf2, 0xf, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf2, 0xf, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf2, + 0xf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xf2, 0xf, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xf1, 0xf, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf1, 0xe, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf0, + 0xd, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xf0, 0xb, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xd0, 0x7, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0x90, 0x4, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x50, + 0x0, 0xdf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x50, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xf9, 0x10, 0x0, 0x3, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xfb, 0x62, 0x3, 0xff, 0xff, + 0x51, 0x25, 0x9e, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xdf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0x7a, 0xce, 0xff, 0xff, 0xff, + 0xfe, 0xdc, 0xa6, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A9 "Ω" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x14, 0x67, + 0x76, 0x52, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0x9e, 0xff, 0xff, + 0xff, 0xff, 0xfa, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xfc, 0xa8, + 0x8a, 0xcf, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf8, 0x20, 0x0, + 0x0, 0x2, 0x9f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xfd, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xef, 0xff, 0xff, 0x20, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0xdf, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xfc, 0x0, + 0x4, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x30, + 0x8, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x80, + 0xd, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xc0, + 0xf, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf0, + 0x2f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf1, + 0x4f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf2, + 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf3, + 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf3, + 0x4f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf3, + 0x3f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf1, + 0xf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf0, + 0xd, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xc0, + 0x9, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x70, + 0x3, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x20, + 0x0, 0xdf, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfc, 0x0, + 0x0, 0x5f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf4, 0x0, + 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xb0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xd1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xfc, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xd2, 0x0, 0x0, + 0x0, 0x0, 0x3d, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x12, 0x22, 0x22, 0x2b, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x18, 0xff, 0xff, 0xa2, 0x22, 0x22, 0x21, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + + /* U+03AA "Ϊ" */ + 0xf, 0xff, 0xf6, 0x0, 0x4, 0xff, 0xff, 0x20, + 0xff, 0xff, 0x60, 0x0, 0x4f, 0xff, 0xf2, 0xf, + 0xff, 0xf6, 0x0, 0x4, 0xff, 0xff, 0x20, 0xff, + 0xff, 0x60, 0x0, 0x4f, 0xff, 0xf2, 0xe, 0xee, + 0xe5, 0x0, 0x4, 0xee, 0xee, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xe0, 0x0, 0x0, + + /* U+03AB "Ϋ" */ + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, + 0x0, 0xef, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, + 0x0, 0xef, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, + 0x0, 0xef, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, + 0x0, 0xef, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xee, 0xea, 0x0, + 0x0, 0xde, 0xee, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xf4, + 0xd, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x90, + 0x3, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfe, 0x0, + 0x0, 0x9f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf4, 0x0, + 0x0, 0xd, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x1f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfa, 0x0, + 0x0, 0xbf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0x40, + 0x5, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xd0, + 0xd, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf6, + 0x7f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xfe, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03AC "ά" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xab, 0xb7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x25, 0x67, 0x64, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xdf, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x8, 0xff, 0xfc, 0x0, 0x0, + 0x1c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd1, 0x0, + 0xdf, 0xff, 0x80, 0x0, 0x2e, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd1, 0x1f, 0xff, 0xf3, 0x0, + 0xd, 0xff, 0xff, 0xf8, 0x31, 0x24, 0xaf, 0xff, + 0xc6, 0xff, 0xfe, 0x0, 0x8, 0xff, 0xff, 0xd2, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xf6, 0x0, 0x6f, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0x30, 0xb, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xf0, 0x0, 0xef, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xfb, 0x0, 0x1f, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0x80, 0x3, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf5, 0x0, 0x4f, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x10, 0x4, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf0, 0x0, 0x4f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x10, + 0x3, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf4, 0x0, 0x1f, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x70, 0x0, 0xef, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xfb, 0x0, 0xa, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xe0, 0x0, 0x5f, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0x10, 0x0, + 0xef, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xf5, 0x0, 0x6, 0xff, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xdf, 0xff, 0x90, + 0x0, 0xc, 0xff, 0xff, 0xe7, 0x21, 0x25, 0xcf, + 0xff, 0xa7, 0xff, 0xfd, 0x0, 0x0, 0x1d, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xe1, 0x2f, 0xff, + 0xf1, 0x0, 0x0, 0x1c, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe3, 0x0, 0xcf, 0xff, 0x60, 0x0, 0x0, + 0x6, 0xdf, 0xff, 0xff, 0xff, 0x91, 0x0, 0x6, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x25, 0x77, + 0x64, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03AD "έ" */ + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6b, 0xba, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x25, 0x77, 0x64, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xef, 0xff, 0xff, 0xff, 0xb4, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x10, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x20, 0x4, 0xff, 0xff, + 0xd6, 0x34, 0x6b, 0xff, 0xff, 0x90, 0x0, 0xaf, + 0xff, 0xc0, 0x0, 0x0, 0x2, 0xaf, 0x50, 0x0, + 0xe, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x10, + 0x0, 0x0, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xe7, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xcf, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, + 0xca, 0x97, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xf8, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x7e, 0x30, 0x3, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x1, 0x9f, 0xff, 0x40, + 0xc, 0xff, 0xff, 0xd5, 0x11, 0x38, 0xef, 0xff, + 0xff, 0x10, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x40, 0x0, 0x4e, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x20, 0x0, 0x0, 0x29, 0xff, + 0xff, 0xff, 0xff, 0xb4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x46, 0x77, 0x64, 0x0, 0x0, 0x0, 0x0, + + /* U+03AE "ή" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5b, 0xbb, 0xba, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x67, 0x76, + 0x30, 0x0, 0x0, 0xb, 0xff, 0xf1, 0x0, 0x7e, + 0xff, 0xff, 0xff, 0xe7, 0x0, 0x0, 0xbf, 0xff, + 0x12, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x10, + 0xb, 0xff, 0xf3, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x0, 0xbf, 0xff, 0xdf, 0xff, 0xb6, + 0x44, 0x6b, 0xff, 0xff, 0xf8, 0xb, 0xff, 0xff, + 0xfd, 0x30, 0x0, 0x0, 0x5, 0xff, 0xff, 0xe0, + 0xbf, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0x2b, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xf4, 0xbf, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x6b, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf7, 0xbf, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x7b, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, 0xbf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x7b, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf7, 0xbf, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x7b, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf7, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x7b, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, 0xbf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x7b, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf7, 0xbf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x7b, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, + 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x7b, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf7, 0xbf, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x7b, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf7, + + /* U+03AF "ί" */ + 0x0, 0x9, 0xff, 0xff, 0xc0, 0x0, 0x1f, 0xff, + 0xfe, 0x10, 0x0, 0x8f, 0xff, 0xf3, 0x0, 0x0, + 0xff, 0xff, 0x70, 0x0, 0x7, 0xff, 0xfb, 0x0, + 0x0, 0xe, 0xff, 0xd1, 0x0, 0x0, 0x3b, 0xbb, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf7, 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, + 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, 0xc, 0xff, + 0xf7, 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, + 0xc, 0xff, 0xf7, 0x0, 0x0, 0xc, 0xff, 0xf7, + 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, 0xc, + 0xff, 0xf7, 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, + 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, 0xc, 0xff, + 0xf7, 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, + 0xc, 0xff, 0xf7, 0x0, 0x0, 0xc, 0xff, 0xf7, + 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, 0xc, + 0xff, 0xf7, 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, + 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, 0xc, 0xff, + 0xf7, 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, + 0xc, 0xff, 0xf7, 0x0, 0x0, 0xc, 0xff, 0xf7, + 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, 0xc, + 0xff, 0xf7, 0x0, 0x0, + + /* U+03B0 "ΰ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfb, + 0x0, 0xd, 0xff, 0xd0, 0x6f, 0xff, 0xb0, 0x0, + 0x5f, 0xff, 0xb0, 0x5, 0xff, 0xf3, 0x6, 0xff, + 0xfb, 0x0, 0x5, 0xff, 0xfb, 0x0, 0xcf, 0xf7, + 0x0, 0x6f, 0xff, 0xb0, 0x0, 0x5f, 0xff, 0xb0, + 0x4f, 0xfb, 0x0, 0x6, 0xff, 0xfb, 0x0, 0x3, + 0x99, 0x96, 0x6, 0x99, 0x10, 0x0, 0x39, 0x99, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf1, 0xdf, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0x1d, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xf1, 0xdf, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0x1d, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf1, + 0xdf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0x1d, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xf1, 0xdf, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x1d, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xf1, 0xdf, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0x1d, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf1, 0xdf, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0x1d, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf1, 0xdf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x1c, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xf1, 0xcf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xb, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf0, 0xaf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfd, + 0x7, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xa0, 0x3f, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xf5, 0x0, 0xcf, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfe, 0x0, + 0x3, 0xff, 0xff, 0xfb, 0x41, 0x13, 0x9f, 0xff, + 0xff, 0x60, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x1, 0x9f, 0xff, 0xff, 0xff, 0xfa, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x67, 0x76, + 0x40, 0x0, 0x0, 0x0, 0x0, + + /* U+03B1 "α" */ + 0x0, 0x0, 0x0, 0x0, 0x25, 0x67, 0x64, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xdf, 0xff, 0xff, 0xff, 0x80, 0x0, 0x8, 0xff, + 0xfc, 0x0, 0x0, 0x1c, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd1, 0x0, 0xdf, 0xff, 0x80, 0x0, 0x2e, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd1, 0x1f, + 0xff, 0xf3, 0x0, 0xd, 0xff, 0xff, 0xf8, 0x31, + 0x24, 0xaf, 0xff, 0xc6, 0xff, 0xfe, 0x0, 0x8, + 0xff, 0xff, 0xd2, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf6, 0x0, + 0x6f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0x30, 0xb, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf0, + 0x0, 0xef, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xfb, 0x0, 0x1f, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x80, 0x3, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xf5, 0x0, 0x4f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x10, 0x4, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf0, 0x0, 0x4f, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x10, 0x3, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf4, 0x0, + 0x1f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0x70, 0x0, 0xef, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfb, + 0x0, 0xa, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xe0, 0x0, 0x5f, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0x10, 0x0, 0xef, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf5, 0x0, 0x6, + 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xdf, 0xff, 0x90, 0x0, 0xc, 0xff, 0xff, 0xe7, + 0x21, 0x25, 0xcf, 0xff, 0xa7, 0xff, 0xfd, 0x0, + 0x0, 0x1d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe1, 0x2f, 0xff, 0xf1, 0x0, 0x0, 0x1c, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe3, 0x0, 0xcf, 0xff, + 0x60, 0x0, 0x0, 0x6, 0xdf, 0xff, 0xff, 0xff, + 0x91, 0x0, 0x6, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x25, 0x77, 0x64, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+03B2 "β" */ + 0x0, 0x0, 0x0, 0x0, 0x46, 0x77, 0x53, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3b, 0xff, + 0xff, 0xff, 0xfe, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd2, + 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xfc, 0x62, 0x12, 0x5c, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x7f, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0x50, 0x0, 0xe, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xfd, 0x0, + 0x3, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf1, 0x0, 0x6f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x40, 0x9, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xf5, 0x0, 0xaf, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0x40, 0xb, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf2, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xfd, 0x0, 0xb, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x50, + 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x2, + 0xcf, 0xff, 0x90, 0x0, 0xb, 0xff, 0xf7, 0x0, + 0x2, 0x34, 0x7b, 0xff, 0xff, 0x90, 0x0, 0x0, + 0xbf, 0xff, 0x70, 0x0, 0xcf, 0xff, 0xff, 0xfc, + 0x40, 0x0, 0x0, 0xb, 0xff, 0xf7, 0x0, 0xc, + 0xff, 0xff, 0xfb, 0x73, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x70, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xfd, + 0x40, 0x0, 0xb, 0xff, 0xf7, 0x0, 0x0, 0x1, + 0x25, 0x9f, 0xff, 0xff, 0x80, 0x0, 0xbf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x1b, 0xff, 0xff, + 0x70, 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0x20, 0xbf, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfa, + 0xb, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf0, 0xbf, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x4b, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf5, 0xbf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x6b, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf5, 0xbf, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x3b, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xe0, 0xbf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xf9, 0xb, 0xff, 0xff, 0xfe, + 0x30, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0x10, + 0xbf, 0xff, 0xff, 0xff, 0x81, 0x0, 0x0, 0x3d, + 0xff, 0xff, 0x70, 0xb, 0xff, 0xf8, 0xcf, 0xff, + 0xfc, 0xab, 0xef, 0xff, 0xff, 0xa0, 0x0, 0xbf, + 0xff, 0x71, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x90, 0x0, 0xb, 0xff, 0xf7, 0x0, 0x5c, 0xff, + 0xff, 0xff, 0xfb, 0x30, 0x0, 0x0, 0xbf, 0xff, + 0x70, 0x0, 0x2, 0x56, 0x76, 0x41, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+03B3 "γ" */ + 0x3f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf3, 0xd, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, + 0x7, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x80, 0x2, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x20, + 0x0, 0xcf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xfc, 0x0, 0x0, 0x6f, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf6, 0x0, + 0x0, 0x1f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf0, 0x0, 0x0, 0xa, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xa0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0x40, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x50, 0x0, 0x0, 0x4, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xa0, 0x0, 0x0, 0xa, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf0, 0x0, 0x0, 0xf, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xf6, 0x0, 0x0, 0x5f, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xfb, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0x10, 0x1, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x60, 0x6, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xc0, 0xc, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf2, 0x2f, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf7, 0x8f, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xfd, 0xdf, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, + + /* U+03B4 "δ" */ + 0x0, 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0x87, 0x77, 0x77, 0x77, 0x77, 0x77, + 0x60, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, + 0xfe, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2d, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1b, 0xff, 0xff, 0xb1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xe4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xad, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4d, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x10, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xd7, + 0x54, 0x59, 0xef, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0x70, 0x0, 0x0, 0x1, 0xaf, + 0xff, 0xfa, 0x0, 0x0, 0xc, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf6, 0x0, + 0x4, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xe0, 0x0, 0x9f, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0x40, 0xd, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf9, 0x1, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xc0, 0x2f, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xfe, 0x3, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xf0, 0x4f, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x4, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf0, 0x2f, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfe, + 0x0, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xc0, 0xd, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf9, 0x0, 0x8f, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0x50, 0x2, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xe0, 0x0, 0xb, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf8, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xb5, 0x21, 0x26, 0xcf, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2a, 0xef, 0xff, 0xff, + 0xff, 0xc6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x35, 0x67, 0x64, 0x10, 0x0, 0x0, + 0x0, 0x0, + + /* U+03B5 "ε" */ + 0x0, 0x0, 0x0, 0x25, 0x77, 0x64, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xef, 0xff, 0xff, 0xff, + 0xb4, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x10, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x20, 0x4, 0xff, + 0xff, 0xd6, 0x34, 0x6b, 0xff, 0xff, 0x90, 0x0, + 0xaf, 0xff, 0xc0, 0x0, 0x0, 0x2, 0xaf, 0x50, + 0x0, 0xe, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x10, 0x0, 0x0, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xe7, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xcf, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, + 0xff, 0xca, 0x97, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf8, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x7e, 0x30, 0x3, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x1, 0x9f, 0xff, + 0x40, 0xc, 0xff, 0xff, 0xd5, 0x11, 0x38, 0xef, + 0xff, 0xff, 0x10, 0x2f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x40, 0x0, 0x4e, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x20, 0x0, 0x0, 0x29, + 0xff, 0xff, 0xff, 0xff, 0xb4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x46, 0x77, 0x64, 0x0, 0x0, 0x0, + 0x0, + + /* U+03B6 "ζ" */ + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x37, 0x77, 0x77, 0x77, 0x78, 0xff, 0xff, 0xc2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xfe, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xe2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf8, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xdb, 0x97, 0x40, 0x0, 0x0, + 0x0, 0x1d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x1, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x5, 0xad, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x26, 0xef, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xdf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xdf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xb4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x56, + 0x41, 0x0, 0x0, 0x0, + + /* U+03B7 "η" */ + 0x0, 0x0, 0x0, 0x0, 0x3, 0x67, 0x76, 0x30, + 0x0, 0x0, 0xb, 0xff, 0xf1, 0x0, 0x7e, 0xff, + 0xff, 0xff, 0xe7, 0x0, 0x0, 0xbf, 0xff, 0x12, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x10, 0xb, + 0xff, 0xf3, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x0, 0xbf, 0xff, 0xdf, 0xff, 0xb6, 0x44, + 0x6b, 0xff, 0xff, 0xf8, 0xb, 0xff, 0xff, 0xfd, + 0x30, 0x0, 0x0, 0x5, 0xff, 0xff, 0xe0, 0xbf, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x2b, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf4, 0xbf, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x6b, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf7, 0xbf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x7b, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, 0xbf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x7b, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf7, 0xbf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x7b, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, + 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x7b, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf7, 0xbf, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x7b, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xf7, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x7b, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, 0xbf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x7b, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf7, 0xbf, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x7b, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xf7, + + /* U+03B8 "θ" */ + 0x0, 0x0, 0x0, 0x0, 0x25, 0x77, 0x64, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xdf, + 0xff, 0xff, 0xff, 0xb3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xd5, 0x21, 0x38, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x2, 0xdf, 0xff, 0xf1, 0x0, 0x0, 0xdf, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0x80, + 0x0, 0x3f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xfe, 0x0, 0x9, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf4, 0x0, + 0xdf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x90, 0x1f, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xfd, 0x4, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf0, 0x7f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0x29, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf4, 0xaf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0x6c, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf7, + 0xcf, 0xff, 0xb7, 0x77, 0x77, 0x77, 0x77, 0x77, + 0x77, 0xef, 0xff, 0x8d, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x8d, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xcf, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x8c, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf7, 0xaf, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x69, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf4, 0x7f, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x24, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xf0, 0x1f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xfd, 0x0, 0xef, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x90, 0x9, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xf4, 0x0, 0x4f, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xfe, + 0x0, 0x0, 0xdf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x80, 0x0, 0x5, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x2, 0xdf, 0xff, 0xf1, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xd6, 0x21, 0x38, 0xef, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x1c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xdf, 0xff, + 0xff, 0xff, 0xb3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x25, 0x77, 0x74, 0x10, 0x0, 0x0, + 0x0, 0x0, + + /* U+03B9 "ι" */ + 0xcf, 0xff, 0x7c, 0xff, 0xf7, 0xcf, 0xff, 0x7c, + 0xff, 0xf7, 0xcf, 0xff, 0x7c, 0xff, 0xf7, 0xcf, + 0xff, 0x7c, 0xff, 0xf7, 0xcf, 0xff, 0x7c, 0xff, + 0xf7, 0xcf, 0xff, 0x7c, 0xff, 0xf7, 0xcf, 0xff, + 0x7c, 0xff, 0xf7, 0xcf, 0xff, 0x7c, 0xff, 0xf7, + 0xcf, 0xff, 0x7c, 0xff, 0xf7, 0xcf, 0xff, 0x7c, + 0xff, 0xf7, 0xcf, 0xff, 0x7c, 0xff, 0xf7, 0xcf, + 0xff, 0x7c, 0xff, 0xf7, 0xcf, 0xff, 0x70, + + /* U+03BA "κ" */ + 0xdf, 0xff, 0x50, 0x0, 0x0, 0x0, 0x2, 0xef, + 0xff, 0xf7, 0xd, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x2, 0xef, 0xff, 0xf6, 0x0, 0xdf, 0xff, 0x50, + 0x0, 0x0, 0x3, 0xef, 0xff, 0xf5, 0x0, 0xd, + 0xff, 0xf5, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0xdf, 0xff, 0x50, 0x0, 0x3, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0xd, 0xff, 0xf5, 0x0, + 0x4, 0xff, 0xff, 0xe3, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x50, 0x4, 0xff, 0xff, 0xe2, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf5, 0x4, 0xff, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x55, 0xff, + 0xff, 0xc1, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xfa, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0x9d, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x90, 0x2e, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf5, + 0x0, 0x4f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x50, 0x0, 0x6f, 0xff, 0xfd, 0x10, + 0x0, 0x0, 0xd, 0xff, 0xf5, 0x0, 0x0, 0x9f, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x50, + 0x0, 0x0, 0xbf, 0xff, 0xf9, 0x0, 0x0, 0xd, + 0xff, 0xf5, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xf6, + 0x0, 0x0, 0xdf, 0xff, 0x50, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xf4, 0x0, 0xd, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xe2, 0x0, 0xdf, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xd1, 0xd, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xb0, 0xdf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0x90, + + /* U+03BB "λ" */ + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xfc, 0xdf, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf6, 0x7f, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf1, 0x1f, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xb0, 0xb, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0x50, 0x5, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xfe, 0x0, 0x0, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf9, 0x0, 0x0, 0xaf, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xf3, 0x0, 0x0, 0x4f, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xd0, 0x0, 0x0, 0xe, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x70, 0x0, 0x0, 0x8, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0x20, 0x0, 0x0, 0x2, + 0xff, 0xff, 0x40, 0x0, 0x0, 0xa, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xa0, 0x0, + 0x0, 0xf, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xf0, 0x0, 0x0, 0x6f, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf5, 0x0, + 0x0, 0xcf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xfb, 0x0, 0x2, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x10, + 0x8, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x70, 0xd, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xd0, + 0x4f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xf3, + + /* U+03BC "μ" */ + 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x6b, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf6, 0xbf, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x6b, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf6, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x6b, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf6, 0xbf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x6b, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf6, 0xbf, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x6b, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf6, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x6b, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf6, 0xbf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x6b, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf6, 0xbf, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x6b, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf6, + 0xbf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0x6b, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf6, 0xbf, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x6b, + 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xf6, 0xbf, 0xff, 0xff, 0xc2, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0x6b, 0xff, 0xff, 0xff, + 0xfa, 0x76, 0x8d, 0xff, 0xff, 0xff, 0xf6, 0xbf, + 0xff, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9f, + 0xff, 0x6b, 0xff, 0xf7, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0x66, 0xff, 0xf6, 0xbf, 0xff, 0x70, 0x5e, + 0xff, 0xff, 0xfc, 0x30, 0x6f, 0xff, 0x6b, 0xff, + 0xf7, 0x0, 0x4, 0x67, 0x52, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03BD "ν" */ + 0x3f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf3, 0xd, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, + 0x7, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x70, 0x1, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x10, + 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xfb, 0x0, 0x0, 0x4f, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf5, 0x0, + 0x0, 0xe, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf0, 0x0, 0x0, 0x8, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x90, 0x0, + 0x0, 0x2, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x70, 0x0, 0x0, 0x5, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xc0, 0x0, 0x0, 0xb, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xf2, 0x0, 0x0, 0x1f, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xf8, 0x0, 0x0, 0x6f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xfe, 0x0, 0x0, 0xcf, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x30, 0x2, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0x90, 0x8, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xe0, 0xd, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf3, 0x3f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf8, 0x8f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xfd, 0xdf, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, + + /* U+03BE "ξ" */ + 0x0, 0x0, 0x0, 0x16, 0xad, 0xef, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x1, 0x9f, 0xff, 0xff, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x1, 0xef, 0xff, + 0xff, 0xdb, 0xa9, 0x99, 0x90, 0x0, 0x0, 0xbf, + 0xff, 0xf8, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xd7, 0x31, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x6, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x4c, 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x3c, 0xff, 0xff, 0xfe, 0xca, 0x70, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xfe, 0x83, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xc3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xfc, 0x85, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x82, + 0x0, 0x0, 0x0, 0x4e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x7, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x37, 0x9c, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4c, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x26, 0xef, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xd3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xae, 0xc9, 0x40, 0x0, 0x0, + + /* U+03BF "ο" */ + 0x0, 0x0, 0x0, 0x0, 0x2, 0x56, 0x76, 0x51, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x8e, 0xff, 0xff, 0xff, 0xfd, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd4, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfa, 0x52, + 0x12, 0x6c, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xe3, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xe1, 0x0, 0x0, 0xdf, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x80, 0x0, + 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0x0, 0xa, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf5, + 0x0, 0xef, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x90, 0x1f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xfc, 0x2, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xe0, 0x3f, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0x4, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf0, 0x3f, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xfe, 0x2, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xd0, + 0x1f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfc, 0x0, 0xef, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x80, 0xa, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf5, 0x0, 0x5f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0x0, 0x0, 0xdf, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0x80, 0x0, 0x5, + 0xff, 0xff, 0xe3, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xe1, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfa, + 0x42, 0x12, 0x6c, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xe4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x8e, 0xff, 0xff, 0xff, + 0xfd, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0x56, 0x76, 0x51, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+03C0 "π" */ + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0x77, 0x77, 0x77, 0xaf, 0xff, 0xe7, 0x77, 0x77, + 0x77, 0x77, 0x7e, 0xff, 0xfb, 0x77, 0x77, 0x70, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf6, 0x0, 0x0, 0x0, + + /* U+03C1 "ρ" */ + 0x0, 0x0, 0x0, 0x0, 0x45, 0x77, 0x53, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3b, 0xff, + 0xff, 0xff, 0xff, 0xa2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0x94, 0x21, 0x38, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x2f, 0xff, 0xfe, 0x30, 0x0, 0x0, + 0x1, 0xbf, 0xff, 0xf6, 0x0, 0x9, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf1, + 0x0, 0xef, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0x70, 0x3f, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfe, 0x7, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf2, 0x9f, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x5c, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xf7, 0xdf, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0x8d, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf9, 0xef, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x8e, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf7, + 0xef, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x5e, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf2, 0xef, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xfe, 0xe, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0x80, 0xef, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xf1, 0xe, 0xff, 0xff, 0xfd, 0x20, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf8, 0x0, 0xef, 0xff, 0xff, + 0xff, 0x93, 0x11, 0x37, 0xef, 0xff, 0xfc, 0x0, + 0xe, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x10, 0x0, 0xef, 0xff, 0x49, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0x10, 0x0, 0xe, + 0xff, 0xf4, 0x3, 0xbf, 0xff, 0xff, 0xff, 0xc5, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x40, 0x0, 0x14, + 0x67, 0x65, 0x10, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03C2 "ς" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x56, 0x77, + 0x65, 0x20, 0x0, 0x0, 0x0, 0x0, 0x4, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xe6, 0x0, 0x0, 0x0, + 0x3c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xb7, + 0x32, 0x12, 0x36, 0xaa, 0x0, 0x0, 0x8f, 0xff, + 0xfb, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xe5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xfc, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2d, 0xff, 0xff, 0xff, 0xfa, 0x51, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1c, 0xff, 0xff, 0xff, 0xff, + 0xfb, 0x50, 0x0, 0x0, 0x0, 0x0, 0x7, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xd2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6b, 0xff, 0xff, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x48, 0xdf, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3d, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x30, 0x2, 0x5d, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xc3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xdf, 0xfe, + 0xc9, 0x40, 0x0, 0x0, 0x0, + + /* U+03C3 "σ" */ + 0x0, 0x0, 0x0, 0x0, 0x2, 0x57, 0x76, 0x41, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x18, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0xa, 0xff, 0xff, 0xf9, 0x42, 0x13, 0x6c, + 0xff, 0xff, 0xf8, 0x77, 0x77, 0x74, 0x0, 0x7f, + 0xff, 0xfd, 0x20, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x6, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xc0, 0x0, 0x0, + 0xb, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf3, 0x0, 0x0, 0xf, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf7, 0x0, 0x0, 0x3f, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xfa, + 0x0, 0x0, 0x4f, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xfc, 0x0, 0x0, + 0x5f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xfd, 0x0, 0x0, 0x6f, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xfe, 0x0, 0x0, 0x5f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfd, + 0x0, 0x0, 0x4f, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xfc, 0x0, 0x0, + 0x2f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, 0xf, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf8, 0x0, 0x0, 0xb, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf4, + 0x0, 0x0, 0x6, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xfd, 0x20, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xf9, 0x41, 0x12, 0x6c, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x29, 0xef, 0xff, 0xff, 0xff, 0xc5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0x57, 0x76, 0x41, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+03C4 "τ" */ + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xde, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd7, 0x77, 0x77, 0x7a, 0xff, 0xfe, 0x77, + 0x77, 0x76, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xd0, 0x0, 0x0, 0x0, + + /* U+03C5 "υ" */ + 0xdf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0x1d, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xf1, 0xdf, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x1d, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xf1, 0xdf, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0x1d, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf1, 0xdf, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0x1d, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf1, 0xdf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x1d, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xf1, 0xdf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0x1d, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf1, 0xdf, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0x1d, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xf1, 0xcf, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0x1c, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf0, + 0xbf, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xa, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x7f, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xfa, 0x3, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0x50, 0xc, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xe0, 0x0, 0x3f, 0xff, 0xff, + 0xb4, 0x11, 0x39, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x19, 0xff, + 0xff, 0xff, 0xff, 0xa2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x36, 0x77, 0x64, 0x0, 0x0, 0x0, + 0x0, + + /* U+03C6 "φ" */ + 0x0, 0x0, 0x0, 0x0, 0x25, 0x40, 0x0, 0x1, + 0x57, 0x76, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xdf, 0xf7, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xfa, 0x20, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0x40, 0x7, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xf0, 0x0, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0xb, 0xff, 0xff, 0xc5, 0x0, + 0x3f, 0xff, 0xfc, 0x31, 0x6e, 0xff, 0xfe, 0x10, + 0x0, 0x6, 0xff, 0xff, 0x90, 0x0, 0x4, 0xff, + 0xff, 0x20, 0x0, 0x1d, 0xff, 0xfa, 0x0, 0x0, + 0xef, 0xff, 0xa0, 0x0, 0x0, 0x5f, 0xff, 0xe0, + 0x0, 0x0, 0x3f, 0xff, 0xf2, 0x0, 0x6f, 0xff, + 0xf1, 0x0, 0x0, 0x5, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x90, 0xb, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xd0, 0x0, 0x0, 0x5, + 0xff, 0xfe, 0x0, 0xef, 0xff, 0x50, 0x0, 0x0, + 0x5, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xf2, 0x2f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x53, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x5, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf6, 0x4f, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0x74, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x5, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf6, 0x2f, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xd0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x41, 0xff, 0xff, 0x50, 0x0, 0x0, 0x5, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf1, + 0xe, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xd0, 0x0, 0x0, 0xa, 0xff, 0xfd, 0x0, 0x9f, + 0xff, 0xf1, 0x0, 0x0, 0x5, 0xff, 0xfd, 0x0, + 0x0, 0x1, 0xff, 0xff, 0x80, 0x4, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x5f, 0xff, 0xd0, 0x0, 0x0, + 0x8f, 0xff, 0xf1, 0x0, 0xc, 0xff, 0xff, 0x30, + 0x0, 0x5, 0xff, 0xfd, 0x0, 0x0, 0x4f, 0xff, + 0xf9, 0x0, 0x0, 0x4f, 0xff, 0xfe, 0x20, 0x0, + 0x5f, 0xff, 0xd0, 0x0, 0x3e, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0x60, 0x5, 0xff, + 0xfd, 0x0, 0x6f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xd8, 0x8f, 0xff, 0xe8, + 0xdf, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6e, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x18, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xb4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x36, 0xaf, + 0xff, 0xe5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+03C7 "χ" */ + 0x9, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0x10, 0x2f, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0x70, 0x0, 0x9f, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xe0, 0x0, 0x1, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xf6, 0x0, 0x0, 0x9, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0x60, 0x0, 0x0, 0x2f, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xfd, 0x0, 0x0, 0xa, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf5, 0x0, 0x2, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xd0, 0x0, 0xaf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x50, + 0x2f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xfd, 0xa, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xf7, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xcf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xe1, 0xdf, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf7, 0x5, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xfe, 0x0, 0xd, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x70, 0x0, 0x5f, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xe0, 0x0, 0x0, + 0xdf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf7, 0x0, 0x0, 0x5, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xc0, 0x0, 0x0, + 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0x50, 0x0, 0xb, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xfd, 0x0, + 0x3, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf6, 0x0, 0xcf, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xe0, 0x5f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0x70, + + /* U+03C8 "ψ" */ + 0x2f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf5, 0x2f, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf5, 0x2f, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xf5, 0x2f, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf5, 0x2f, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xf5, 0x2f, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf3, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xf5, 0x2f, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf3, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xf5, 0x2f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf5, + 0x2f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf5, 0x2f, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf5, 0x2f, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xf5, 0x2f, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf5, 0x2f, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xf5, 0x1f, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf3, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf4, 0x1f, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf3, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xf4, 0xf, 0xff, 0xf3, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, + 0xf, 0xff, 0xf5, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf1, 0xc, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf0, 0x9, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0xf, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xb0, 0x3, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0xf, 0xff, 0xf3, 0x0, 0x0, + 0x8, 0xff, 0xff, 0x60, 0x0, 0xaf, 0xff, 0xfb, + 0x10, 0x0, 0xf, 0xff, 0xf3, 0x0, 0x0, 0x9f, + 0xff, 0xfe, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xfa, + 0x53, 0x2f, 0xff, 0xf5, 0x25, 0x8e, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x2, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x1b, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3a, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0x56, 0x7f, 0xff, 0xf9, + 0x76, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03C9 "ω" */ + 0x0, 0x8, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x70, 0x0, 0x0, 0x7f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xe0, 0x0, 0x0, 0xef, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xf6, 0x0, 0x5, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xfc, 0x0, 0xa, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x20, 0xf, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x4b, 0xbb, 0x90, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x70, 0x4f, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, + 0x7f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xf0, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf2, 0xcf, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf4, 0xdf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf5, 0xef, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf6, 0xef, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf6, 0xdf, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf5, 0xcf, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf4, + 0xaf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf2, 0x7f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xf0, 0x2f, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xb0, 0xd, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0x50, 0x6, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x3f, 0xff, 0x7e, 0xff, 0xa0, 0x0, + 0x0, 0x1e, 0xff, 0xfe, 0x0, 0x0, 0xdf, 0xff, + 0xf9, 0x10, 0x6, 0xef, 0xfe, 0x6, 0xff, 0xfa, + 0x20, 0x4, 0xef, 0xff, 0xf5, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xfe, 0xff, 0xff, 0xf4, 0x0, 0xbf, + 0xff, 0xfe, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x4, 0xef, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x1c, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x1a, 0xff, 0xff, 0xff, 0xc3, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xfd, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x15, 0x67, 0x62, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x47, 0x76, 0x30, 0x0, + 0x0, 0x0, + + /* U+03CA "ϊ" */ + 0x4f, 0xff, 0xf2, 0x0, 0x8, 0xff, 0xfd, 0x4f, + 0xff, 0xf2, 0x0, 0x8, 0xff, 0xfd, 0x4f, 0xff, + 0xf2, 0x0, 0x8, 0xff, 0xfd, 0x4f, 0xff, 0xf2, + 0x0, 0x8, 0xff, 0xfd, 0x4e, 0xee, 0xe1, 0x0, + 0x7, 0xee, 0xec, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf7, 0x0, 0x0, + + /* U+03CB "ϋ" */ + 0x0, 0x7, 0xff, 0xff, 0x0, 0x0, 0xbf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf0, 0x0, + 0xb, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0x0, 0x0, 0xbf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xf0, 0x0, 0xb, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x6, 0xee, 0xee, 0x0, 0x0, + 0x9e, 0xee, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0x1d, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf1, 0xdf, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0x1d, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xf1, 0xdf, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0x1d, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf1, + 0xdf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0x1d, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xf1, 0xdf, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x1d, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xf1, 0xdf, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0x1d, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf1, 0xdf, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0x1d, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf1, 0xcf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x1c, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xf0, 0xbf, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xa, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x7f, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xfa, + 0x3, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0x50, 0xc, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xe0, 0x0, 0x3f, 0xff, + 0xff, 0xb4, 0x11, 0x39, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x19, + 0xff, 0xff, 0xff, 0xff, 0xa2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x36, 0x77, 0x64, 0x0, 0x0, + 0x0, 0x0, + + /* U+03CC "ό" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xfe, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xbb, 0xb3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0x56, 0x76, 0x51, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x8e, 0xff, 0xff, + 0xff, 0xfd, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd4, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xfa, 0x52, 0x12, 0x6c, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x6, 0xff, 0xff, 0xe3, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0xdf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0x80, 0x0, 0x5f, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0x0, 0xa, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf5, 0x0, 0xef, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x90, 0x1f, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xfc, 0x2, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xe0, 0x3f, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x4, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf0, 0x3f, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfe, + 0x2, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xd0, 0x1f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xfc, 0x0, 0xef, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x80, 0xa, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf5, 0x0, 0x5f, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x0, 0x0, + 0xdf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0x80, 0x0, 0x5, 0xff, 0xff, 0xe3, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xfa, 0x42, 0x12, 0x6c, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x8e, 0xff, 0xff, 0xff, 0xfd, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x56, + 0x76, 0x51, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03CD "ύ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xbb, 0xb1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf1, 0xdf, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0x1d, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xf1, 0xdf, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0x1d, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf1, + 0xdf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0x1d, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xf1, 0xdf, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x1d, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xf1, 0xdf, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0x1d, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf1, 0xdf, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0x1d, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf1, 0xdf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x1c, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xf1, 0xcf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xb, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf0, 0xaf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfd, + 0x7, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xa0, 0x3f, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xf5, 0x0, 0xcf, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfe, 0x0, + 0x3, 0xff, 0xff, 0xfb, 0x41, 0x13, 0x9f, 0xff, + 0xff, 0x60, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x1, 0x9f, 0xff, 0xff, 0xff, 0xfa, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x67, 0x76, + 0x40, 0x0, 0x0, 0x0, 0x0, + + /* U+03CE "ώ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9b, 0xb8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x7f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xe0, 0x0, 0x0, 0xef, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xf6, 0x0, 0x5, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xfc, 0x0, + 0xa, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x20, 0xf, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x4b, 0xbb, 0x90, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0x70, 0x4f, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xb0, 0x7f, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xf0, 0xaf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf2, 0xcf, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf4, 0xdf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf5, 0xef, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf6, + 0xef, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xf6, 0xdf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf5, 0xcf, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf4, 0xaf, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xf2, 0x7f, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xf0, 0x2f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xb0, 0xd, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x50, 0x6, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x3f, 0xff, 0x7e, + 0xff, 0xa0, 0x0, 0x0, 0x1e, 0xff, 0xfe, 0x0, + 0x0, 0xdf, 0xff, 0xf9, 0x10, 0x6, 0xef, 0xfe, + 0x6, 0xff, 0xfa, 0x20, 0x4, 0xef, 0xff, 0xf5, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xfe, 0xff, 0xff, + 0xf4, 0x0, 0xbf, 0xff, 0xfe, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x4, 0xef, 0xff, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x1c, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x1a, 0xff, 0xff, + 0xff, 0xc3, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xfd, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x15, + 0x67, 0x62, 0x0, 0x0, 0x0, 0x0, 0x0, 0x47, + 0x76, 0x30, 0x0, 0x0, 0x0, + + /* U+03F4 "ϴ" */ + 0x0, 0x0, 0x0, 0x0, 0x7, 0x88, 0x82, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xc0, + 0x0, 0x0, 0x49, 0x99, 0x50, 0x0, 0xcf, 0xfe, + 0x15, 0x99, 0x95, 0x8f, 0xff, 0x80, 0x4, 0xff, + 0xf5, 0x8, 0xff, 0xf8, 0x8f, 0xff, 0x80, 0xc, + 0xff, 0x90, 0x8, 0xff, 0xf8, 0x8f, 0xff, 0x80, + 0x3f, 0xfd, 0x0, 0x8, 0xff, 0xf8, 0x8f, 0xff, + 0x80, 0xbf, 0xf3, 0x0, 0x8, 0xff, 0xf8 +}; + + +/*--------------------- + * GLYPH DESCRIPTION + *--------------------*/ + +static const lv_font_fmt_txt_glyph_dsc_t glyph_dsc[] = { + {.bitmap_index = 0, .adv_w = 0, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0} /* id = 0 reserved */, + {.bitmap_index = 0, .adv_w = 213, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 0, .adv_w = 214, .box_w = 6, .box_h = 35, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 105, .adv_w = 272, .box_w = 13, .box_h = 13, .ofs_x = 2, .ofs_y = 22}, + {.bitmap_index = 190, .adv_w = 427, .box_w = 27, .box_h = 38, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 703, .adv_w = 427, .box_w = 24, .box_h = 44, .ofs_x = 1, .ofs_y = -5}, + {.bitmap_index = 1231, .adv_w = 683, .box_w = 38, .box_h = 38, .ofs_x = 2, .ofs_y = -2}, + {.bitmap_index = 1953, .adv_w = 513, .box_w = 29, .box_h = 37, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 2490, .adv_w = 146, .box_w = 5, .box_h = 13, .ofs_x = 2, .ofs_y = 22}, + {.bitmap_index = 2523, .adv_w = 256, .box_w = 13, .box_h = 46, .ofs_x = 2, .ofs_y = -10}, + {.bitmap_index = 2822, .adv_w = 256, .box_w = 13, .box_h = 46, .ofs_x = 1, .ofs_y = -10}, + {.bitmap_index = 3121, .adv_w = 299, .box_w = 17, .box_h = 15, .ofs_x = 1, .ofs_y = 21}, + {.bitmap_index = 3249, .adv_w = 449, .box_w = 24, .box_h = 24, .ofs_x = 2, .ofs_y = 6}, + {.bitmap_index = 3537, .adv_w = 214, .box_w = 6, .box_h = 12, .ofs_x = 3, .ofs_y = -7}, + {.bitmap_index = 3573, .adv_w = 256, .box_w = 14, .box_h = 5, .ofs_x = 1, .ofs_y = 11}, + {.bitmap_index = 3608, .adv_w = 214, .box_w = 6, .box_h = 5, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 3623, .adv_w = 213, .box_w = 14, .box_h = 37, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 3882, .adv_w = 427, .box_w = 23, .box_h = 36, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 4296, .adv_w = 427, .box_w = 13, .box_h = 35, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 4524, .adv_w = 427, .box_w = 24, .box_h = 35, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 4944, .adv_w = 427, .box_w = 23, .box_h = 36, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 5358, .adv_w = 427, .box_w = 25, .box_h = 35, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5796, .adv_w = 427, .box_w = 23, .box_h = 36, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 6210, .adv_w = 427, .box_w = 23, .box_h = 36, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 6624, .adv_w = 427, .box_w = 23, .box_h = 35, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 7027, .adv_w = 427, .box_w = 23, .box_h = 36, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 7441, .adv_w = 427, .box_w = 23, .box_h = 36, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 7855, .adv_w = 214, .box_w = 6, .box_h = 25, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 7930, .adv_w = 214, .box_w = 6, .box_h = 32, .ofs_x = 3, .ofs_y = -7}, + {.bitmap_index = 8026, .adv_w = 449, .box_w = 24, .box_h = 25, .ofs_x = 2, .ofs_y = 5}, + {.bitmap_index = 8326, .adv_w = 449, .box_w = 24, .box_h = 15, .ofs_x = 2, .ofs_y = 10}, + {.bitmap_index = 8506, .adv_w = 449, .box_w = 24, .box_h = 25, .ofs_x = 2, .ofs_y = 5}, + {.bitmap_index = 8806, .adv_w = 427, .box_w = 23, .box_h = 36, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 9220, .adv_w = 780, .box_w = 46, .box_h = 47, .ofs_x = 2, .ofs_y = -11}, + {.bitmap_index = 10301, .adv_w = 513, .box_w = 34, .box_h = 35, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 10896, .adv_w = 513, .box_w = 27, .box_h = 35, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 11369, .adv_w = 555, .box_w = 31, .box_h = 37, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 11943, .adv_w = 555, .box_w = 30, .box_h = 35, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 12468, .adv_w = 513, .box_w = 27, .box_h = 35, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 12941, .adv_w = 470, .box_w = 25, .box_h = 35, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 13379, .adv_w = 597, .box_w = 33, .box_h = 37, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 13990, .adv_w = 555, .box_w = 28, .box_h = 35, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 14480, .adv_w = 214, .box_w = 5, .box_h = 35, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 14568, .adv_w = 384, .box_w = 20, .box_h = 36, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 14928, .adv_w = 513, .box_w = 29, .box_h = 35, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 15436, .adv_w = 427, .box_w = 23, .box_h = 35, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 15839, .adv_w = 640, .box_w = 34, .box_h = 35, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 16434, .adv_w = 555, .box_w = 28, .box_h = 35, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 16924, .adv_w = 597, .box_w = 34, .box_h = 37, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 17553, .adv_w = 513, .box_w = 27, .box_h = 35, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 18026, .adv_w = 597, .box_w = 34, .box_h = 39, .ofs_x = 2, .ofs_y = -3}, + {.bitmap_index = 18689, .adv_w = 555, .box_w = 32, .box_h = 35, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 19249, .adv_w = 513, .box_w = 28, .box_h = 37, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 19767, .adv_w = 470, .box_w = 28, .box_h = 35, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 20257, .adv_w = 555, .box_w = 28, .box_h = 36, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 20761, .adv_w = 513, .box_w = 32, .box_h = 35, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 21321, .adv_w = 725, .box_w = 45, .box_h = 35, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 22109, .adv_w = 513, .box_w = 32, .box_h = 35, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 22669, .adv_w = 513, .box_w = 32, .box_h = 35, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 23229, .adv_w = 470, .box_w = 29, .box_h = 35, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 23737, .adv_w = 214, .box_w = 10, .box_h = 45, .ofs_x = 3, .ofs_y = -10}, + {.bitmap_index = 23962, .adv_w = 213, .box_w = 14, .box_h = 37, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 24221, .adv_w = 214, .box_w = 11, .box_h = 45, .ofs_x = 0, .ofs_y = -10}, + {.bitmap_index = 24469, .adv_w = 360, .box_w = 21, .box_h = 19, .ofs_x = 1, .ofs_y = 17}, + {.bitmap_index = 24669, .adv_w = 427, .box_w = 28, .box_h = 4, .ofs_x = -1, .ofs_y = -10}, + {.bitmap_index = 24725, .adv_w = 256, .box_w = 9, .box_h = 7, .ofs_x = 2, .ofs_y = 29}, + {.bitmap_index = 24757, .adv_w = 427, .box_w = 24, .box_h = 27, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 25081, .adv_w = 427, .box_w = 22, .box_h = 36, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 25477, .adv_w = 384, .box_w = 23, .box_h = 27, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 25788, .adv_w = 427, .box_w = 23, .box_h = 36, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 26202, .adv_w = 427, .box_w = 24, .box_h = 27, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 26526, .adv_w = 214, .box_w = 15, .box_h = 36, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 26796, .adv_w = 427, .box_w = 23, .box_h = 37, .ofs_x = 1, .ofs_y = -11}, + {.bitmap_index = 27222, .adv_w = 427, .box_w = 21, .box_h = 35, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 27590, .adv_w = 171, .box_w = 5, .box_h = 35, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 27678, .adv_w = 171, .box_w = 11, .box_h = 46, .ofs_x = -3, .ofs_y = -11}, + {.bitmap_index = 27931, .adv_w = 384, .box_w = 21, .box_h = 35, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 28299, .adv_w = 171, .box_w = 5, .box_h = 35, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 28387, .adv_w = 640, .box_w = 34, .box_h = 26, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 28829, .adv_w = 427, .box_w = 21, .box_h = 26, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 29102, .adv_w = 427, .box_w = 25, .box_h = 27, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 29440, .adv_w = 427, .box_w = 22, .box_h = 36, .ofs_x = 3, .ofs_y = -10}, + {.bitmap_index = 29836, .adv_w = 427, .box_w = 23, .box_h = 36, .ofs_x = 1, .ofs_y = -10}, + {.bitmap_index = 30250, .adv_w = 256, .box_w = 14, .box_h = 26, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 30432, .adv_w = 384, .box_w = 22, .box_h = 27, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 30729, .adv_w = 214, .box_w = 13, .box_h = 35, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 30957, .adv_w = 427, .box_w = 21, .box_h = 26, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 31230, .adv_w = 384, .box_w = 24, .box_h = 25, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 31530, .adv_w = 555, .box_w = 35, .box_h = 25, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 31968, .adv_w = 384, .box_w = 24, .box_h = 25, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 32268, .adv_w = 384, .box_w = 24, .box_h = 36, .ofs_x = 0, .ofs_y = -11}, + {.bitmap_index = 32700, .adv_w = 384, .box_w = 23, .box_h = 25, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 32988, .adv_w = 256, .box_w = 14, .box_h = 47, .ofs_x = 1, .ofs_y = -11}, + {.bitmap_index = 33317, .adv_w = 200, .box_w = 5, .box_h = 46, .ofs_x = 4, .ofs_y = -10}, + {.bitmap_index = 33432, .adv_w = 256, .box_w = 14, .box_h = 47, .ofs_x = 1, .ofs_y = -11}, + {.bitmap_index = 33761, .adv_w = 449, .box_w = 25, .box_h = 9, .ofs_x = 2, .ofs_y = 12}, + {.bitmap_index = 33874, .adv_w = 213, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 33874, .adv_w = 427, .box_w = 26, .box_h = 37, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 34355, .adv_w = 427, .box_w = 24, .box_h = 24, .ofs_x = 1, .ofs_y = 5}, + {.bitmap_index = 34643, .adv_w = 427, .box_w = 27, .box_h = 35, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 35116, .adv_w = 200, .box_w = 5, .box_h = 46, .ofs_x = 4, .ofs_y = -10}, + {.bitmap_index = 35231, .adv_w = 427, .box_w = 23, .box_h = 47, .ofs_x = 2, .ofs_y = -11}, + {.bitmap_index = 35772, .adv_w = 256, .box_w = 14, .box_h = 5, .ofs_x = 1, .ofs_y = 30}, + {.bitmap_index = 35807, .adv_w = 566, .box_w = 36, .box_h = 36, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 36455, .adv_w = 288, .box_w = 18, .box_h = 18, .ofs_x = 0, .ofs_y = 17}, + {.bitmap_index = 36617, .adv_w = 427, .box_w = 21, .box_h = 22, .ofs_x = 3, .ofs_y = 2}, + {.bitmap_index = 36848, .adv_w = 449, .box_w = 24, .box_h = 16, .ofs_x = 2, .ofs_y = 10}, + {.bitmap_index = 37040, .adv_w = 256, .box_w = 14, .box_h = 5, .ofs_x = 1, .ofs_y = 11}, + {.bitmap_index = 37075, .adv_w = 566, .box_w = 36, .box_h = 36, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 37723, .adv_w = 307, .box_w = 14, .box_h = 13, .ofs_x = 3, .ofs_y = 22}, + {.bitmap_index = 37814, .adv_w = 449, .box_w = 24, .box_h = 30, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 38174, .adv_w = 256, .box_w = 16, .box_h = 18, .ofs_x = 0, .ofs_y = 17}, + {.bitmap_index = 38318, .adv_w = 256, .box_w = 16, .box_h = 18, .ofs_x = 0, .ofs_y = 17}, + {.bitmap_index = 38462, .adv_w = 427, .box_w = 21, .box_h = 35, .ofs_x = 3, .ofs_y = -10}, + {.bitmap_index = 38830, .adv_w = 413, .box_w = 27, .box_h = 45, .ofs_x = -1, .ofs_y = -10}, + {.bitmap_index = 39438, .adv_w = 215, .box_w = 6, .box_h = 5, .ofs_x = 4, .ofs_y = 15}, + {.bitmap_index = 39453, .adv_w = 427, .box_w = 21, .box_h = 22, .ofs_x = 3, .ofs_y = 2}, + {.bitmap_index = 39684, .adv_w = 641, .box_w = 38, .box_h = 38, .ofs_x = 2, .ofs_y = -2}, + {.bitmap_index = 40406, .adv_w = 256, .box_w = 9, .box_h = 7, .ofs_x = 5, .ofs_y = 29}, + {.bitmap_index = 40438, .adv_w = 513, .box_w = 34, .box_h = 35, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 41033, .adv_w = 602, .box_w = 39, .box_h = 35, .ofs_x = -3, .ofs_y = 0}, + {.bitmap_index = 41716, .adv_w = 644, .box_w = 39, .box_h = 35, .ofs_x = -3, .ofs_y = 0}, + {.bitmap_index = 42399, .adv_w = 295, .box_w = 16, .box_h = 35, .ofs_x = -3, .ofs_y = 0}, + {.bitmap_index = 42679, .adv_w = 595, .box_w = 38, .box_h = 37, .ofs_x = -3, .ofs_y = -1}, + {.bitmap_index = 43382, .adv_w = 657, .box_w = 44, .box_h = 35, .ofs_x = -3, .ofs_y = 0}, + {.bitmap_index = 44152, .adv_w = 578, .box_w = 37, .box_h = 36, .ofs_x = -3, .ofs_y = 0}, + {.bitmap_index = 44818, .adv_w = 171, .box_w = 18, .box_h = 36, .ofs_x = -4, .ofs_y = 0}, + {.bitmap_index = 45142, .adv_w = 513, .box_w = 34, .box_h = 35, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 45737, .adv_w = 513, .box_w = 27, .box_h = 35, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 46210, .adv_w = 423, .box_w = 23, .box_h = 35, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 46613, .adv_w = 513, .box_w = 34, .box_h = 35, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 47208, .adv_w = 513, .box_w = 27, .box_h = 35, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 47681, .adv_w = 470, .box_w = 29, .box_h = 35, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 48189, .adv_w = 555, .box_w = 28, .box_h = 35, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 48679, .adv_w = 597, .box_w = 34, .box_h = 37, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 49308, .adv_w = 214, .box_w = 5, .box_h = 35, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 49396, .adv_w = 513, .box_w = 29, .box_h = 35, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 49904, .adv_w = 513, .box_w = 32, .box_h = 35, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 50464, .adv_w = 640, .box_w = 34, .box_h = 35, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 51059, .adv_w = 555, .box_w = 28, .box_h = 35, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 51549, .adv_w = 499, .box_w = 27, .box_h = 35, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 52022, .adv_w = 597, .box_w = 34, .box_h = 37, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 52651, .adv_w = 555, .box_w = 28, .box_h = 35, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 53141, .adv_w = 513, .box_w = 27, .box_h = 35, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 53614, .adv_w = 475, .box_w = 25, .box_h = 35, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 54052, .adv_w = 470, .box_w = 28, .box_h = 35, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 54542, .adv_w = 513, .box_w = 32, .box_h = 35, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 55102, .adv_w = 613, .box_w = 35, .box_h = 38, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 55767, .adv_w = 513, .box_w = 32, .box_h = 35, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 56327, .adv_w = 642, .box_w = 36, .box_h = 35, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 56957, .adv_w = 574, .box_w = 32, .box_h = 36, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 57533, .adv_w = 214, .box_w = 15, .box_h = 42, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 57848, .adv_w = 513, .box_w = 32, .box_h = 42, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 58520, .adv_w = 444, .box_w = 25, .box_h = 37, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 58983, .adv_w = 342, .box_w = 19, .box_h = 37, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 59335, .adv_w = 427, .box_w = 21, .box_h = 46, .ofs_x = 3, .ofs_y = -10}, + {.bitmap_index = 59818, .adv_w = 171, .box_w = 10, .box_h = 36, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 59998, .adv_w = 420, .box_w = 21, .box_h = 37, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 60387, .adv_w = 444, .box_w = 25, .box_h = 27, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 60725, .adv_w = 442, .box_w = 23, .box_h = 46, .ofs_x = 3, .ofs_y = -10}, + {.bitmap_index = 61254, .adv_w = 384, .box_w = 24, .box_h = 35, .ofs_x = 0, .ofs_y = -10}, + {.bitmap_index = 61674, .adv_w = 428, .box_w = 25, .box_h = 36, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 62124, .adv_w = 342, .box_w = 19, .box_h = 27, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 62381, .adv_w = 339, .box_w = 20, .box_h = 46, .ofs_x = 1, .ofs_y = -11}, + {.bitmap_index = 62841, .adv_w = 427, .box_w = 21, .box_h = 36, .ofs_x = 3, .ofs_y = -10}, + {.bitmap_index = 63219, .adv_w = 427, .box_w = 23, .box_h = 37, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 63645, .adv_w = 171, .box_w = 5, .box_h = 25, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 63708, .adv_w = 383, .box_w = 21, .box_h = 25, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 63971, .adv_w = 384, .box_w = 24, .box_h = 35, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 64391, .adv_w = 427, .box_w = 21, .box_h = 35, .ofs_x = 3, .ofs_y = -10}, + {.bitmap_index = 64759, .adv_w = 384, .box_w = 24, .box_h = 25, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 65059, .adv_w = 344, .box_w = 19, .box_h = 46, .ofs_x = 2, .ofs_y = -10}, + {.bitmap_index = 65496, .adv_w = 427, .box_w = 25, .box_h = 27, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 65834, .adv_w = 530, .box_w = 32, .box_h = 25, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 66234, .adv_w = 437, .box_w = 23, .box_h = 36, .ofs_x = 3, .ofs_y = -10}, + {.bitmap_index = 66648, .adv_w = 370, .box_w = 21, .box_h = 37, .ofs_x = 2, .ofs_y = -11}, + {.bitmap_index = 67037, .adv_w = 474, .box_w = 28, .box_h = 27, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 67415, .adv_w = 303, .box_w = 17, .box_h = 25, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 67628, .adv_w = 420, .box_w = 21, .box_h = 26, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 67901, .adv_w = 498, .box_w = 29, .box_h = 36, .ofs_x = 1, .ofs_y = -10}, + {.bitmap_index = 68423, .adv_w = 403, .box_w = 25, .box_h = 35, .ofs_x = 0, .ofs_y = -10}, + {.bitmap_index = 68861, .adv_w = 548, .box_w = 30, .box_h = 35, .ofs_x = 2, .ofs_y = -10}, + {.bitmap_index = 69386, .adv_w = 600, .box_w = 34, .box_h = 26, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 69828, .adv_w = 171, .box_w = 14, .box_h = 35, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 70073, .adv_w = 420, .box_w = 21, .box_h = 36, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 70451, .adv_w = 427, .box_w = 25, .box_h = 37, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 70914, .adv_w = 420, .box_w = 21, .box_h = 37, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 71303, .adv_w = 600, .box_w = 34, .box_h = 37, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 71932, .adv_w = 256, .box_w = 18, .box_h = 7, .ofs_x = -1, .ofs_y = 29} +}; + +/*--------------------- + * CHARACTER MAPPING + *--------------------*/ + +static const uint8_t glyph_id_ofs_list_1[] = { + 0, 0, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 0, + 13, 14, 15, 16, 0, 17, 18, 19, + 0, 0, 0, 20, 0, 21 +}; + +static const uint8_t glyph_id_ofs_list_2[] = { + 0, 0, 1, 0, 2, 3, 4, 0, + 5 +}; + +/*Collect the unicode lists and glyph_id offsets*/ +static const lv_font_fmt_txt_cmap_t cmaps[] = +{ + { + .range_start = 32, .range_length = 95, .glyph_id_start = 1, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 160, .range_length = 30, .glyph_id_start = 96, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_1, .list_length = 30, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 900, .range_length = 9, .glyph_id_start = 118, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_2, .list_length = 9, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 910, .range_length = 20, .glyph_id_start = 124, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 931, .range_length = 44, .glyph_id_start = 144, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 1012, .range_length = 1, .glyph_id_start = 188, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + } +}; + + + +/*-------------------- + * ALL CUSTOM DATA + *--------------------*/ + +#if LVGL_VERSION_MAJOR == 8 +/*Store all the custom data of the font*/ +static lv_font_fmt_txt_glyph_cache_t cache; +#endif + +#if LVGL_VERSION_MAJOR >= 8 +static const lv_font_fmt_txt_dsc_t font_dsc = { +#else +static lv_font_fmt_txt_dsc_t font_dsc = { +#endif + .glyph_bitmap = glyph_bitmap, + .glyph_dsc = glyph_dsc, + .cmaps = cmaps, + .kern_dsc = NULL, + .kern_scale = 0, + .cmap_num = 6, + .bpp = 4, + .kern_classes = 0, + .bitmap_format = 0, +#if LVGL_VERSION_MAJOR == 8 + .cache = &cache +#endif + +}; + +extern const lv_font_t lv_font_montserrat_48; + + +/*----------------- + * PUBLIC FONT + *----------------*/ + +/*Initialize a public general font descriptor*/ +#if LVGL_VERSION_MAJOR >= 8 +const lv_font_t lv_font_arial_48 = { +#else +lv_font_t lv_font_arial_48 = { +#endif + .get_glyph_dsc = lv_font_get_glyph_dsc_fmt_txt, /*Function pointer to get glyph's data*/ + .get_glyph_bitmap = lv_font_get_bitmap_fmt_txt, /*Function pointer to get glyph's bitmap*/ + .line_height = 53, /*The maximum line height required by the font*/ + .base_line = 11, /*Baseline measured from the bottom of the line*/ +#if !(LVGL_VERSION_MAJOR == 6 && LVGL_VERSION_MINOR == 0) + .subpx = LV_FONT_SUBPX_NONE, +#endif +#if LV_VERSION_CHECK(7, 4, 0) || LVGL_VERSION_MAJOR >= 8 + .underline_position = -5, + .underline_thickness = 4, +#endif + .dsc = &font_dsc, /*The custom font data. Will be accessed by `get_glyph_bitmap/dsc` */ +#if LV_VERSION_CHECK(8, 2, 0) || LVGL_VERSION_MAJOR >= 9 + .fallback = &lv_font_montserrat_48, +#endif + .user_data = NULL, +}; + + + +#endif /*#if LV_FONT_ARIAL_48*/ diff --git a/src/fonts/lv_font_arial_50.c b/src/fonts/lv_font_arial_50.c new file mode 100644 index 0000000000..661903fb85 --- /dev/null +++ b/src/fonts/lv_font_arial_50.c @@ -0,0 +1,10460 @@ +/******************************************************************************* + * Size: 50 px + * Bpp: 4 + * Opts: --bpp 4 --size 50 --no-compress --stride 1 --align 1 --font Arial Greek Regular.ttf --range 32-127,160-255,880-1023 --format lvgl -o lv_font_arial_50.c + ******************************************************************************/ + +#ifdef __has_include + #if __has_include("lvgl.h") + #ifndef LV_LVGL_H_INCLUDE_SIMPLE + #define LV_LVGL_H_INCLUDE_SIMPLE + #endif + #endif +#endif + +#ifdef LV_LVGL_H_INCLUDE_SIMPLE + #include "lvgl.h" +#else + #include "lvgl/lvgl.h" +#endif + + + +#ifndef LV_FONT_ARIAL_50 +#define LV_FONT_ARIAL_50 1 +#endif + +#if LV_FONT_ARIAL_50 + +/*----------------- + * BITMAPS + *----------------*/ + +/*Store the image of the glyphs*/ +static LV_ATTRIBUTE_LARGE_CONST const uint8_t glyph_bitmap[] = { + /* U+0020 " " */ + + /* U+0021 "!" */ + 0xcf, 0xff, 0xfa, 0xcf, 0xff, 0xfa, 0xcf, 0xff, + 0xfa, 0xcf, 0xff, 0xfa, 0xcf, 0xff, 0xfa, 0xcf, + 0xff, 0xfa, 0xcf, 0xff, 0xfa, 0xcf, 0xff, 0xfa, + 0xcf, 0xff, 0xfa, 0xaf, 0xff, 0xf9, 0x9f, 0xff, + 0xf8, 0x8f, 0xff, 0xf7, 0x7f, 0xff, 0xf6, 0x6f, + 0xff, 0xf5, 0x5f, 0xff, 0xf3, 0x4f, 0xff, 0xf2, + 0x3f, 0xff, 0xf1, 0x2f, 0xff, 0xf0, 0xf, 0xff, + 0xf0, 0xf, 0xff, 0xe0, 0xe, 0xff, 0xd0, 0xd, + 0xff, 0xc0, 0xc, 0xff, 0xb0, 0xb, 0xff, 0xa0, + 0xa, 0xff, 0x90, 0x9, 0xff, 0x80, 0x8, 0xff, + 0x70, 0x2, 0x66, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x11, 0x10, 0x9f, 0xff, 0xf7, + 0x9f, 0xff, 0xf7, 0x9f, 0xff, 0xf7, 0x9f, 0xff, + 0xf7, 0x9f, 0xff, 0xf7, + + /* U+0022 "\"" */ + 0xbf, 0xff, 0xf5, 0x0, 0x9f, 0xff, 0xf7, 0xbf, + 0xff, 0xf5, 0x0, 0x9f, 0xff, 0xf7, 0xbf, 0xff, + 0xf5, 0x0, 0x9f, 0xff, 0xf7, 0xbf, 0xff, 0xf5, + 0x0, 0x9f, 0xff, 0xf7, 0xbf, 0xff, 0xf5, 0x0, + 0x9f, 0xff, 0xf7, 0xaf, 0xff, 0xf5, 0x0, 0x9f, + 0xff, 0xf6, 0x9f, 0xff, 0xf3, 0x0, 0x7f, 0xff, + 0xf5, 0x6f, 0xff, 0xf1, 0x0, 0x5f, 0xff, 0xf2, + 0x3f, 0xff, 0xe0, 0x0, 0x2f, 0xff, 0xf0, 0xf, + 0xff, 0xc0, 0x0, 0xf, 0xff, 0xd0, 0xe, 0xff, + 0x90, 0x0, 0xc, 0xff, 0xa0, 0xb, 0xff, 0x70, + 0x0, 0x9, 0xff, 0x70, 0x7, 0xee, 0x40, 0x0, + 0x6, 0xee, 0x40, + + /* U+0023 "#" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcc, 0xc9, 0x0, + 0x0, 0x0, 0x7, 0xcc, 0xc1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf5, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x80, 0x0, 0x0, 0x0, 0xcf, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x50, 0x0, 0x0, 0x0, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x20, 0x0, + 0x0, 0x2, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xfc, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf2, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x6f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x4b, 0xbb, 0xbb, 0xbe, + 0xff, 0xfb, 0xbb, 0xbb, 0xbb, 0xdf, 0xff, 0xcb, + 0xbb, 0xb2, 0x0, 0x0, 0x0, 0xe, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x90, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x60, 0x0, 0x0, 0x0, 0xef, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x30, 0x0, 0x0, 0x1, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xfc, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf9, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0xe, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x6f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf4, 0x4b, 0xbb, 0xcf, 0xff, 0xdb, 0xbb, + 0xbb, 0xbb, 0xff, 0xfe, 0xbb, 0xbb, 0xbb, 0xb2, + 0x0, 0x0, 0x6f, 0xff, 0x30, 0x0, 0x0, 0x1, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfd, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf6, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x60, 0x0, 0x0, 0x0, 0xef, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x13, 0x33, 0x0, + 0x0, 0x0, 0x0, 0x33, 0x32, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0024 "$" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x48, 0xbe, 0xff, + 0xda, 0x61, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xef, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x1d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf7, + 0x17, 0xff, 0x25, 0xdf, 0xff, 0xff, 0x10, 0x0, + 0x3, 0xff, 0xff, 0xd2, 0x0, 0x7f, 0xf2, 0x0, + 0xbf, 0xff, 0xfa, 0x0, 0x0, 0xaf, 0xff, 0xf2, + 0x0, 0x7, 0xff, 0x20, 0x1, 0xef, 0xff, 0xf0, + 0x0, 0xf, 0xff, 0xf8, 0x0, 0x0, 0x7f, 0xf2, + 0x0, 0x7, 0xff, 0xff, 0x50, 0x3, 0xff, 0xff, + 0x30, 0x0, 0x7, 0xff, 0x20, 0x0, 0x2f, 0xff, + 0xf8, 0x0, 0x4f, 0xff, 0xf1, 0x0, 0x0, 0x7f, + 0xf2, 0x0, 0x0, 0xb9, 0x74, 0x10, 0x5, 0xff, + 0xff, 0x10, 0x0, 0x7, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf3, 0x0, 0x0, + 0x7f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0x90, 0x0, 0x7, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x30, + 0x0, 0x7f, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xfe, 0x30, 0x7, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0x91, 0x7f, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xfe, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xc8, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3a, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4b, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf7, 0xbf, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0x20, 0x2a, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf2, + 0x0, 0x7, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0x20, 0x0, 0xb, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xf2, 0x0, 0x0, 0x5f, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0x20, 0x0, 0x1, + 0xff, 0xff, 0x70, 0x69, 0xcf, 0x60, 0x0, 0x0, + 0x7f, 0xf2, 0x0, 0x0, 0xf, 0xff, 0xf8, 0xf, + 0xff, 0xf9, 0x0, 0x0, 0x7, 0xff, 0x20, 0x0, + 0x0, 0xff, 0xff, 0x70, 0xef, 0xff, 0xe0, 0x0, + 0x0, 0x7f, 0xf2, 0x0, 0x0, 0x2f, 0xff, 0xf6, + 0xa, 0xff, 0xff, 0x30, 0x0, 0x7, 0xff, 0x20, + 0x0, 0x6, 0xff, 0xff, 0x20, 0x5f, 0xff, 0xfb, + 0x0, 0x0, 0x7f, 0xf2, 0x0, 0x0, 0xdf, 0xff, + 0xe0, 0x0, 0xef, 0xff, 0xf5, 0x0, 0x7, 0xff, + 0x20, 0x0, 0x9f, 0xff, 0xf7, 0x0, 0x7, 0xff, + 0xff, 0xf5, 0x0, 0x7f, 0xf2, 0x0, 0xaf, 0xff, + 0xfe, 0x0, 0x0, 0xc, 0xff, 0xff, 0xfb, 0x59, + 0xff, 0x58, 0xef, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x1d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xe9, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0x7c, 0xff, 0x86, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+0025 "%" */ + 0x0, 0x0, 0x3, 0x67, 0x63, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0x88, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4d, 0xff, 0xff, + 0xfe, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfc, 0x9b, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf6, 0x0, 0x2, 0xef, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xfb, 0x0, 0x0, 0x5, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x50, + 0x0, 0x0, 0xe, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf1, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf3, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x40, + 0x0, 0x0, 0x5, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xf4, 0x0, 0x0, 0x0, 0xdf, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x30, 0x0, + 0x0, 0x5f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xf2, 0x0, 0x0, 0xd, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x0, 0x0, 0x5, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0x60, 0x0, 0x0, 0x2f, 0xff, + 0xb0, 0x0, 0x0, 0xdf, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfe, 0x0, + 0x0, 0xa, 0xff, 0xf5, 0x0, 0x0, 0x6f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xfc, 0x41, 0x3a, 0xff, 0xfc, 0x0, + 0x0, 0xd, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x10, 0x0, 0x6, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0xfc, 0x10, 0x0, 0x0, + 0xef, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xae, 0xfe, 0xb5, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xa0, 0x0, 0x0, 0x5, 0xbf, 0xff, 0xd9, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xf2, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfa, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x20, 0x0, 0x7, 0xff, 0xfd, 0x40, + 0x17, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xa0, 0x0, 0x0, + 0xef, 0xff, 0x20, 0x0, 0x6, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf2, 0x0, 0x0, 0x5f, 0xff, 0x90, 0x0, 0x0, + 0xe, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xfa, 0x0, 0x0, 0x9, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x20, + 0x0, 0x0, 0xbf, 0xff, 0x20, 0x0, 0x0, 0x7, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xa0, 0x0, 0x0, 0xd, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0x20, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x10, 0x0, 0x0, 0x8, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0x80, 0x0, 0x0, 0xf, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x10, 0x0, 0x8, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xfd, 0x51, 0x28, 0xff, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xfe, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xae, 0xfe, 0xc7, 0x0, 0x0, + 0x0, + + /* U+0026 "&" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x67, 0x64, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xaf, 0xff, 0xff, 0xff, + 0x91, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xf9, 0x43, 0x5d, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf4, 0x0, 0x0, 0xb, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf8, + 0x0, 0x0, 0xc, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf5, + 0x0, 0xa, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf3, + 0x2c, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xef, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xbf, 0xff, 0xff, 0xfa, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2c, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4e, 0xff, 0xff, 0xf8, 0xcf, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xd2, 0x1, 0xef, 0xff, 0xfe, 0x10, + 0x0, 0xd, 0xb7, 0x40, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0xb0, 0x0, 0x3, 0xff, 0xff, 0xfb, 0x0, + 0x3, 0xff, 0xff, 0xa0, 0x0, 0xa, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf8, 0x0, + 0x7f, 0xff, 0xf5, 0x0, 0x2, 0xff, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf5, 0xd, + 0xff, 0xff, 0x10, 0x0, 0x7f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0xff, + 0xff, 0xb0, 0x0, 0xb, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0xcf, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0xc, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0xbf, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xef, 0xff, 0xff, 0xfe, 0x20, 0x0, + 0x0, 0xbf, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, + 0x4, 0xef, 0xff, 0xff, 0xff, 0xfe, 0x20, 0x0, + 0x2, 0xff, 0xff, 0xfd, 0x30, 0x0, 0x0, 0x2a, + 0xff, 0xff, 0xfd, 0xff, 0xff, 0xfe, 0x30, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xc8, 0x78, 0xcf, 0xff, + 0xff, 0xfc, 0x17, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfb, 0x0, 0x8, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x8, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x1, 0x8e, 0xff, 0xff, 0xff, 0xfd, 0x81, 0x0, + 0x0, 0x0, 0x6, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x2, 0x56, 0x77, 0x52, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0x50, 0x0, + + /* U+0027 "'" */ + 0xbf, 0xff, 0xf4, 0xbf, 0xff, 0xf4, 0xbf, 0xff, + 0xf4, 0xbf, 0xff, 0xf4, 0xbf, 0xff, 0xf4, 0xbf, + 0xff, 0xf4, 0xaf, 0xff, 0xf3, 0x8f, 0xff, 0xf0, + 0x5f, 0xff, 0xd0, 0x2f, 0xff, 0xb0, 0xf, 0xff, + 0x80, 0xd, 0xff, 0x50, 0x9, 0xee, 0x20, + + /* U+0028 "(" */ + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf8, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0x60, 0x0, 0x0, 0x0, 0xaf, 0xfd, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xf9, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0x80, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x30, 0x0, 0x0, 0x5, 0xff, + 0xff, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x90, 0x0, + 0x0, 0x0, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x90, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xf7, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0x80, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x60, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0x60, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xf8, + + /* U+0029 ")" */ + 0xd, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x80, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0x90, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0xc, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0x50, 0x0, 0x0, 0x0, 0xc, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xf5, 0x0, 0x0, 0x0, 0x0, + + /* U+002A "*" */ + 0x0, 0x0, 0x0, 0xf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf3, 0x0, + 0x0, 0x10, 0x7, 0xe9, 0x20, 0xc, 0xff, 0x10, + 0x16, 0xce, 0x0, 0xcf, 0xff, 0xc4, 0xaf, 0xf2, + 0x9f, 0xff, 0xf3, 0x1f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x81, 0x8c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xa5, 0x0, 0x0, 0x37, 0xcf, + 0xff, 0xf9, 0x63, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0x9f, 0xff, 0x70, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xe0, 0x9f, 0xff, 0x50, 0x0, 0x0, 0xa, + 0xff, 0xf6, 0x1, 0xef, 0xff, 0x30, 0x0, 0x2, + 0xef, 0xfc, 0x0, 0x5, 0xff, 0xf9, 0x0, 0x0, + 0x2, 0xcf, 0x30, 0x0, 0xb, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x40, 0x0, 0x0, 0x12, 0x0, 0x0, + + /* U+002B "+" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x11, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x22, 0x22, + 0x22, 0x22, 0x8f, 0xff, 0xb2, 0x22, 0x22, 0x22, + 0x22, 0x13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x63, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x3f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+002C "," */ + 0x1, 0x11, 0x10, 0xaf, 0xff, 0xf5, 0xaf, 0xff, + 0xf5, 0xaf, 0xff, 0xf5, 0xaf, 0xff, 0xf5, 0xaf, + 0xff, 0xf5, 0x0, 0x3f, 0xf5, 0x0, 0x4f, 0xf3, + 0x0, 0x9f, 0xf1, 0x1, 0xef, 0xc0, 0x1b, 0xff, + 0x40, 0xbf, 0xf9, 0x0, 0x3f, 0x70, 0x0, 0x0, + 0x0, 0x0, + + /* U+002D "-" */ + 0x38, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x6, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0x6f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x16, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0x6f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x10, + + /* U+002E "." */ + 0x1, 0x11, 0x10, 0x9f, 0xff, 0xf7, 0x9f, 0xff, + 0xf7, 0x9f, 0xff, 0xf7, 0x9f, 0xff, 0xf7, 0x9f, + 0xff, 0xf7, + + /* U+002F "/" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x58, 0x86, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0030 "0" */ + 0x0, 0x0, 0x0, 0x3, 0x8c, 0xef, 0xfe, 0xb7, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc1, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0xeb, 0xcf, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xb3, 0x0, 0x0, 0x5e, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x6f, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xf2, 0x0, + 0x0, 0xef, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf9, 0x0, 0x4, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x0, + 0xa, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x50, 0xe, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x90, + 0x2f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xd0, 0x5f, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf0, + 0x7f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf2, 0x9f, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf4, + 0xaf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf5, 0xcf, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf6, + 0xcf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf7, 0xdf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf7, + 0xdf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf8, 0xcf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf7, + 0xcf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf7, 0xbf, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf6, + 0xaf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf5, 0x8f, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf3, + 0x6f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xf1, 0x3f, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xe0, + 0xf, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xb0, 0xc, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x70, + 0x7, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0x20, 0x2, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xfc, 0x0, + 0x0, 0xbf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xf5, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x8, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xfb, 0x53, 0x47, 0xdf, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3b, + 0xff, 0xff, 0xff, 0xfe, 0x81, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0x67, 0x76, 0x30, + 0x0, 0x0, 0x0, 0x0, + + /* U+0031 "1" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x3d, 0xff, 0xff, 0xff, + 0xfb, 0x0, 0x19, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0x7, 0xef, 0xff, 0xff, 0xab, 0xff, 0xfb, 0x7f, + 0xff, 0xff, 0xf7, 0xa, 0xff, 0xfb, 0x7f, 0xff, + 0xfd, 0x30, 0xa, 0xff, 0xfb, 0x7f, 0xfe, 0x60, + 0x0, 0xa, 0xff, 0xfb, 0x7d, 0x60, 0x0, 0x0, + 0xa, 0xff, 0xfb, 0x10, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfb, + + /* U+0032 "2" */ + 0x0, 0x0, 0x0, 0x0, 0x49, 0xce, 0xff, 0xec, + 0x84, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x1b, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x1d, + 0xff, 0xff, 0xff, 0xdb, 0xbd, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xe7, 0x10, + 0x0, 0x2, 0x9f, 0xff, 0xff, 0x80, 0x0, 0x4, + 0xff, 0xff, 0xd2, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0x20, 0x0, 0xbf, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf8, 0x0, + 0x1f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xd0, 0x5, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0x0, 0x7f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xf2, 0x4, 0x89, 0xbc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xdf, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xef, 0xff, 0xfe, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xfd, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfe, 0x44, + 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x41, + 0xc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x32, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf3, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x36, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf3, + + /* U+0033 "3" */ + 0x0, 0x0, 0x0, 0x5, 0xad, 0xef, 0xed, 0x95, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xe6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xfe, 0xcb, 0xcf, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xfd, 0x40, 0x0, 0x0, 0x6e, + 0xff, 0xff, 0x80, 0x0, 0x3, 0xff, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xf1, 0x0, + 0xa, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf7, 0x0, 0xf, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xfb, 0x0, + 0x3f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xfd, 0x0, 0x2, 0x58, 0xa1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xef, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0x68, 0xbf, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xff, 0xfb, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, + 0xfd, 0x71, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0x20, 0x2, 0x7e, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf9, 0x0, 0x14, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf9, + 0xaf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf8, 0x9f, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf6, + 0x5f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xf1, 0xf, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xc0, + 0x8, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0x40, 0x0, 0xef, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xe8, 0x43, 0x47, 0xcf, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x10, 0x0, + 0x0, 0x0, 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6d, + 0xff, 0xff, 0xff, 0xfe, 0x81, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x15, 0x67, 0x65, 0x20, + 0x0, 0x0, 0x0, 0x0, + + /* U+0034 "4" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xfd, 0xcf, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xf3, + 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x80, 0xbf, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xfc, 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf2, 0x0, 0xbf, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x60, 0x0, 0xbf, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xfb, 0x0, + 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xe1, 0x0, 0x0, 0xbf, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x40, 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0xd, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xa0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf7, 0x4f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf7, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x1, + 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0xcf, + 0xff, 0xb1, 0x11, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xa0, 0x0, 0x0, + + /* U+0035 "5" */ + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x6, 0xff, 0xfe, 0x44, 0x44, 0x44, 0x44, + 0x44, 0x44, 0x44, 0x0, 0x0, 0x9, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0x50, 0x17, 0xbe, 0xfe, 0xda, + 0x50, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x39, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0x60, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x9, 0xff, 0xff, 0xfe, 0x83, 0x0, 0x2, 0x7e, + 0xff, 0xff, 0xfa, 0x0, 0xc, 0xff, 0xff, 0xb1, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x50, + 0xe, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xd0, 0x0, 0x13, 0x51, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfc, + 0x7b, 0xcd, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf9, 0xaf, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf5, + 0x7f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xf1, 0x2f, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x90, + 0xc, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x2e, 0xff, 0xff, 0x20, 0x3, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x4, 0xef, 0xff, 0xf7, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xe8, 0x43, 0x46, 0xbf, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x5e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6d, + 0xff, 0xff, 0xff, 0xfe, 0xa2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x15, 0x67, 0x65, 0x30, + 0x0, 0x0, 0x0, 0x0, + + /* U+0036 "6" */ + 0x0, 0x0, 0x0, 0x0, 0x38, 0xce, 0xff, 0xeb, + 0x71, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3c, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xfd, 0xbb, 0xef, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xf7, 0x10, 0x0, 0x4, + 0xdf, 0xff, 0xfb, 0x0, 0x0, 0x1f, 0xff, 0xfd, + 0x20, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, 0x30, + 0x0, 0x9f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0x90, 0x1, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xd0, + 0x7, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5c, 0xba, 0x90, 0xc, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xd0, 0x0, 0x5, 0xad, 0xee, 0xda, + 0x50, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xa0, 0x4, + 0xdf, 0xff, 0xff, 0xff, 0xfe, 0x60, 0x0, 0x0, + 0xbf, 0xff, 0x80, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0xcf, 0xff, 0x87, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0xdf, 0xff, 0xbf, 0xff, 0xf9, 0x31, 0x1, 0x6c, + 0xff, 0xff, 0xf7, 0x0, 0xef, 0xff, 0xff, 0xfd, + 0x20, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x20, + 0xef, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0x90, 0xef, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf0, + 0xef, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xf4, 0xdf, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf7, + 0xcf, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf9, 0xbf, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xfa, + 0x9f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfa, 0x6f, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf9, + 0x3f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf7, 0xf, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf4, + 0xa, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf0, 0x4, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x90, + 0x0, 0xcf, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0x20, 0x0, 0x3f, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x1, 0xbf, 0xff, 0xf9, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xfd, 0x74, 0x34, 0x9e, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x20, 0x0, + 0x0, 0x0, 0x3, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xcf, 0xff, 0xff, 0xff, 0xc6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x46, 0x76, 0x51, + 0x0, 0x0, 0x0, 0x0, + + /* U+0037 "7" */ + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0x24, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, + 0x47, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0038 "8" */ + 0x0, 0x0, 0x0, 0x3, 0x8c, 0xef, 0xfd, 0xb7, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe3, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xdb, 0xbe, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xa2, 0x0, 0x0, 0x3c, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0xaf, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf7, 0x0, + 0x0, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xfd, 0x0, 0x4, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x10, + 0x6, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0x30, 0x6, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x30, + 0x5, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0x10, 0x2, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xfd, 0x0, + 0x0, 0xcf, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xf7, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0x91, 0x0, 0x0, 0x2b, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xcb, 0xbd, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x3d, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xfb, 0x50, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x10, 0x0, + 0x0, 0x2d, 0xff, 0xff, 0xc5, 0x10, 0x13, 0x7e, + 0xff, 0xff, 0xe2, 0x0, 0x0, 0xdf, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfd, 0x0, + 0x9, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0x70, 0x1f, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xe0, + 0x6f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf4, 0xaf, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf8, + 0xcf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xfa, 0xdf, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfa, + 0xcf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf9, 0xbf, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf8, + 0x7f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf4, 0x3f, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf0, + 0xc, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0x80, 0x3, 0xff, 0xff, 0xfa, + 0x10, 0x0, 0x0, 0x1, 0xbf, 0xff, 0xfe, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xf9, 0x53, 0x35, 0x9f, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x40, 0x0, + 0x0, 0x0, 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6c, + 0xff, 0xff, 0xff, 0xff, 0xb4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x14, 0x67, 0x76, 0x40, + 0x0, 0x0, 0x0, 0x0, + + /* U+0039 "9" */ + 0x0, 0x0, 0x0, 0x5, 0xad, 0xef, 0xec, 0x83, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xc3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xec, 0xce, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xb3, 0x0, 0x0, 0x3c, + 0xff, 0xff, 0xa0, 0x0, 0x2, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf4, 0x0, + 0xa, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xfd, 0x0, 0x1f, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x40, + 0x5f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x90, 0x9f, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xe0, + 0xbf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf1, 0xcf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf4, + 0xcf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xf6, 0xbf, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf8, + 0xaf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xf9, 0x6f, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfa, + 0x2f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xfa, 0xc, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfb, + 0x4, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x1, + 0xcf, 0xff, 0xff, 0xfa, 0x0, 0xaf, 0xff, 0xff, + 0xd6, 0x20, 0x2, 0x7e, 0xff, 0xfc, 0xff, 0xfa, + 0x0, 0xd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x5a, 0xff, 0xf9, 0x0, 0x1, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf4, 0xb, 0xff, 0xf8, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0x20, 0xc, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x16, + 0xbd, 0xee, 0xc8, 0x30, 0x0, 0xf, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xb0, 0x5, 0x78, 0xa1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x60, + 0xf, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0x10, 0xc, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfa, 0x0, + 0x7, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xf2, 0x0, 0x1, 0xff, 0xff, 0xe3, + 0x0, 0x0, 0x0, 0x1c, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xa5, 0x33, 0x5a, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xaf, + 0xff, 0xff, 0xff, 0xfa, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x46, 0x77, 0x63, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+003A ":" */ + 0x9f, 0xff, 0xf7, 0x9f, 0xff, 0xf7, 0x9f, 0xff, + 0xf7, 0x9f, 0xff, 0xf7, 0x9f, 0xff, 0xf7, 0x1, + 0x11, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x11, 0x10, 0x9f, + 0xff, 0xf7, 0x9f, 0xff, 0xf7, 0x9f, 0xff, 0xf7, + 0x9f, 0xff, 0xf7, 0x9f, 0xff, 0xf7, + + /* U+003B ";" */ + 0xaf, 0xff, 0xf5, 0xaf, 0xff, 0xf5, 0xaf, 0xff, + 0xf5, 0xaf, 0xff, 0xf5, 0xaf, 0xff, 0xf5, 0x1, + 0x11, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x11, 0x10, 0xaf, + 0xff, 0xf5, 0xaf, 0xff, 0xf5, 0xaf, 0xff, 0xf5, + 0xaf, 0xff, 0xf5, 0xaf, 0xff, 0xf5, 0x0, 0x3f, + 0xf5, 0x0, 0x4f, 0xf3, 0x0, 0x9f, 0xf1, 0x1, + 0xef, 0xc0, 0x1b, 0xff, 0x40, 0xbf, 0xf9, 0x0, + 0x3f, 0x70, 0x0, 0x0, 0x0, 0x0, + + /* U+003C "<" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x17, + 0xd7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0x9f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4b, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xdf, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x9f, 0xff, 0xff, + 0xff, 0xfe, 0x81, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4b, 0xff, 0xff, 0xff, 0xff, 0xc6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xdf, 0xff, 0xff, 0xff, + 0xfa, 0x30, 0x0, 0x0, 0x0, 0x0, 0x2, 0x9f, + 0xff, 0xff, 0xff, 0xfe, 0x71, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4b, 0xff, 0xff, 0xff, 0xff, 0xb4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xdf, 0xff, + 0xff, 0xff, 0xf9, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xfd, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xa3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xfa, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xc6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6d, 0xff, 0xff, 0xff, + 0xfe, 0x82, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xbf, 0xff, 0xff, 0xff, 0xfb, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x28, + 0xff, 0xff, 0xff, 0xff, 0xd6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6d, 0xff, 0xff, + 0xff, 0xff, 0x92, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xbf, 0xff, 0xff, 0xff, 0xfb, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x29, 0xff, 0xff, 0xff, 0xff, 0xe7, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x7e, 0xff, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xcf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3a, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x8e, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, + + /* U+003D "=" */ + 0x3, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x13, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf6, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x63, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x31, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x63, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x3f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x63, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, + + /* U+003E ">" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xe8, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xb4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xfd, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xe8, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7d, + 0xff, 0xff, 0xff, 0xff, 0xa4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xbf, 0xff, 0xff, + 0xff, 0xfd, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x28, 0xef, 0xff, 0xff, 0xff, 0xe8, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6c, 0xff, 0xff, 0xff, 0xff, 0xa3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xaf, 0xff, + 0xff, 0xff, 0xfc, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x17, 0xef, 0xff, 0xff, 0xff, + 0xe8, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5b, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x9f, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x29, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xbf, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x7d, 0xff, 0xff, 0xff, 0xfe, 0x71, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x29, 0xff, 0xff, + 0xff, 0xff, 0xc5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xcf, 0xff, 0xff, 0xff, 0xfa, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x7e, 0xff, 0xff, 0xff, + 0xfe, 0x81, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3a, + 0xff, 0xff, 0xff, 0xff, 0xd6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xcf, 0xff, 0xff, 0xff, 0xfb, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xff, 0x92, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xd7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xfc, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0x93, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+003F "?" */ + 0x0, 0x0, 0x0, 0x0, 0x14, 0x67, 0x76, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6c, + 0xff, 0xff, 0xff, 0xff, 0xc5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3d, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd2, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xf9, 0x53, 0x35, 0xaf, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0xef, 0xff, 0xfb, + 0x10, 0x0, 0x0, 0x2, 0xcf, 0xff, 0xfe, 0x10, + 0x8, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0x90, 0xe, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xe0, + 0x3f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf3, 0x7f, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf5, + 0x9f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf5, 0x0, 0x24, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1c, + 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xdf, 0xff, 0xfd, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, + 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xfc, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x11, 0x11, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x11, 0x11, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, + + /* U+0040 "@" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x24, 0x66, 0x77, 0x76, 0x42, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x48, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xeb, + 0x61, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x8e, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xb3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3d, 0xff, 0xff, + 0xff, 0xfb, 0x85, 0x32, 0x22, 0x34, 0x6a, 0xef, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0xb5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x9f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xb2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x8f, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xe5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xdf, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfd, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xc1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x36, 0x77, 0x51, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x7e, 0xff, 0xff, 0xff, 0x91, 0x0, 0x1f, + 0xff, 0xf4, 0x0, 0x1, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x2d, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x20, 0x4f, + 0xff, 0xf0, 0x0, 0x0, 0x7f, 0xff, 0x80, 0x0, + 0x0, 0x6, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe2, 0x8f, + 0xff, 0xd0, 0x0, 0x0, 0xe, 0xff, 0xe0, 0x0, + 0x0, 0xe, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xd7, 0x43, 0x6c, 0xff, 0xfc, 0xbf, + 0xff, 0xa0, 0x0, 0x0, 0x8, 0xff, 0xf3, 0x0, + 0x0, 0x4f, 0xff, 0x80, 0x0, 0x0, 0x1, 0xef, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x4, 0xff, 0xf7, 0x0, + 0x0, 0xaf, 0xff, 0x10, 0x0, 0x0, 0xb, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0xff, 0xf9, 0x0, + 0x0, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfc, 0x0, + 0x4, 0xff, 0xf5, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfd, 0x0, + 0x8, 0xff, 0xf1, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfd, 0x0, + 0xb, 0xff, 0xe0, 0x0, 0x0, 0xd, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfd, 0x0, + 0xe, 0xff, 0xb0, 0x0, 0x0, 0x2f, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfc, 0x0, + 0xf, 0xff, 0x90, 0x0, 0x0, 0x6f, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfa, 0x0, + 0x1f, 0xff, 0x80, 0x0, 0x0, 0xaf, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf6, 0x0, + 0x2f, 0xff, 0x70, 0x0, 0x0, 0xbf, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf2, 0x0, + 0x2f, 0xff, 0x70, 0x0, 0x0, 0xcf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xd0, 0x0, + 0x2f, 0xff, 0x80, 0x0, 0x0, 0xdf, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x70, 0x0, + 0x1f, 0xff, 0x90, 0x0, 0x0, 0xcf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x10, 0x0, + 0xf, 0xff, 0xb0, 0x0, 0x0, 0xaf, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, + 0xd, 0xff, 0xe0, 0x0, 0x0, 0x7f, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xd0, 0x0, 0x0, + 0xb, 0xff, 0xf1, 0x0, 0x0, 0x2f, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x9, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x7, 0xff, 0xf6, 0x0, 0x0, 0xc, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x1, 0xbf, 0xff, 0xff, 0xf2, + 0x0, 0x2, 0xcf, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xfb, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x5e, 0xff, 0xff, 0xff, 0xfb, + 0x33, 0x9f, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0x20, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xeb, 0xce, 0xff, 0xfd, 0x8f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0x90, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc1, 0x3f, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xff, 0x91, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x2, + 0x9d, 0xff, 0xd8, 0x20, 0x0, 0x0, 0x7c, 0xff, + 0xeb, 0x71, 0x0, 0x0, 0x0, 0x48, 0x88, 0x70, + 0x0, 0x1, 0xef, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x5f, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xa1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfe, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xaf, 0xff, 0xfe, 0x20, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xfc, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x8f, 0xff, 0xff, 0xd2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xfe, + 0x94, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xaf, 0xff, 0xff, 0xfb, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xef, 0xff, 0xff, + 0xff, 0xfc, 0x97, 0x54, 0x33, 0x34, 0x57, 0x9c, + 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x91, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x91, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x6a, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xc8, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x34, 0x67, 0x77, 0x76, 0x54, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0041 "A" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xfa, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfb, + 0x4f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x70, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf3, 0x9, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xfe, 0x0, 0x4f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x90, 0x0, 0xef, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf3, 0x0, + 0x8, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfd, + 0x0, 0x0, 0x2f, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0x70, 0x0, 0x0, 0xcf, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xf2, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xfb, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xd0, 0x0, 0x0, 0xe, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0x30, 0x0, 0x5, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfa, 0x0, + 0x0, 0xbf, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xf1, 0x0, 0x1f, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0x70, 0x7, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xfd, 0x0, 0xdf, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xf4, + + /* U+0042 "B" */ + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0xdb, 0x84, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd6, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc1, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x10, 0x0, + 0x5f, 0xff, 0xf9, 0x44, 0x44, 0x44, 0x45, 0x57, + 0x9c, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x5f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x19, + 0xff, 0xff, 0xf3, 0x0, 0x5f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xf9, 0x0, 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfd, 0x0, + 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xfe, 0x0, 0x5f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0x0, 0x5f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xfd, 0x0, 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfa, 0x0, + 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xf4, 0x0, 0x5f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xef, 0xff, 0xc0, 0x0, 0x5f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x37, 0xcf, 0xff, 0xfe, + 0x10, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xc1, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xb2, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x5f, 0xff, 0xf9, 0x44, 0x44, 0x44, + 0x44, 0x56, 0x7a, 0xef, 0xff, 0xff, 0xf7, 0x0, + 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xbf, 0xff, 0xff, 0x40, 0x5f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xd0, 0x5f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf3, 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf7, + 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfa, 0x5f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xfb, 0x5f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xfa, 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf8, + 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf4, 0x5f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf0, 0x5f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xaf, 0xff, + 0xff, 0x80, 0x5f, 0xff, 0xf9, 0x44, 0x44, 0x44, + 0x44, 0x45, 0x69, 0xcf, 0xff, 0xff, 0xfe, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x30, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x80, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xed, 0xb8, 0x40, 0x0, 0x0, 0x0, + + /* U+0043 "C" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x46, + 0x77, 0x65, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x9d, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3b, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xe5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xcf, 0xff, 0xff, + 0xff, 0xec, 0xba, 0xbc, 0xff, 0xff, 0xff, 0xfc, + 0x10, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xf8, 0x30, 0x0, 0x0, 0x0, 0x6d, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0x91, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xa0, 0x0, 0x9, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0x10, 0x1, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xf6, 0x0, 0x6f, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xeb, 0x73, 0x0, 0xa, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0x73, 0x0, 0x0, 0x8f, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xfe, 0xa1, 0x3, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xfe, 0x0, 0xe, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0x80, 0x0, 0x7f, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0xef, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfb, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0x30, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xf9, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xbf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0xfe, 0x72, 0x0, + 0x0, 0x0, 0x29, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, 0xfe, + 0xca, 0xab, 0xef, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5b, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xb4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x25, 0x67, 0x76, 0x53, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+0044 "D" */ + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xec, 0xa7, 0x40, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe7, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x30, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x1f, 0xff, + 0xfc, 0x44, 0x44, 0x44, 0x44, 0x56, 0x7a, 0xdf, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x1, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x29, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x1f, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xfc, 0x0, 0x1, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xf5, 0x0, 0x1f, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xc0, 0x1, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0x30, 0x1f, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xf8, 0x1, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xc0, 0x1f, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0x1, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf3, 0x1f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x51, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf6, + 0x1f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x71, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf8, 0x1f, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x71, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf6, 0x1f, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0x61, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xf4, 0x1f, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0x11, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xf0, 0x1f, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xfb, 0x1, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0x60, 0x1f, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xf1, 0x1, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xfa, 0x0, 0x1f, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0x20, 0x1, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x90, + 0x0, 0x1f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xaf, 0xff, 0xff, 0xe0, 0x0, + 0x1, 0xff, 0xff, 0xc4, 0x44, 0x44, 0x44, 0x45, + 0x68, 0xae, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe3, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc2, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x50, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xed, 0xb9, + 0x51, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0045 "E" */ + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0xf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd0, 0xf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd0, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, + 0xf, 0xff, 0xfc, 0x44, 0x44, 0x44, 0x44, 0x44, + 0x44, 0x44, 0x44, 0x44, 0x44, 0x30, 0xf, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0xf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf7, 0x0, 0xf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf7, 0x0, 0xf, 0xff, 0xfc, 0x44, 0x44, 0x44, + 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x42, 0x0, + 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xfc, 0x44, 0x44, 0x44, + 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x43, + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0xf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0xf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + + /* U+0046 "F" */ + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x2f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x2f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf2, 0xff, 0xff, 0xd4, 0x44, 0x44, 0x44, + 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0xf, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf8, 0x0, 0xf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0xf, 0xff, 0xfd, + 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, + 0x20, 0x0, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0047 "G" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x24, + 0x67, 0x77, 0x64, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0xa4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xff, 0xfe, 0xba, 0xaa, 0xce, 0xff, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xc6, 0x10, 0x0, 0x0, 0x0, + 0x27, 0xef, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xd4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xfd, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0x50, 0x0, 0x4f, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xb0, 0x0, 0xcf, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xf0, 0x2, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4d, 0x84, 0x0, 0x7, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x6f, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x5f, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0x4f, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x2f, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x24, + 0x44, 0x44, 0x44, 0x44, 0x4f, 0xff, 0xfb, 0xf, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xfb, + 0xc, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xfb, 0x8, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xfb, 0x3, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xfb, 0x0, 0xcf, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xfb, 0x0, 0x5f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xfb, 0x0, 0xc, 0xff, + 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfb, 0x0, 0x2, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x19, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xfa, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x18, 0xef, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xfb, 0x62, + 0x0, 0x0, 0x2, 0x6a, 0xff, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x2, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0x9e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xb6, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x14, 0x67, 0x77, 0x65, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0048 "H" */ + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x1f, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xf1, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0x1f, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xf1, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0x1f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf1, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0x1f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf1, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0x1f, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xf1, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x1f, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf1, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0x1f, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xf1, 0xff, 0xff, 0xd5, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x5c, 0xff, + 0xff, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf1, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x1f, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xf1, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0x1f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf1, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0x1f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf1, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0x1f, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xf1, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x1f, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf1, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0x1f, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xf1, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0x1f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf1, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x1f, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xf1, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0x1f, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xf1, + + /* U+0049 "I" */ + 0x6f, 0xff, 0xf5, 0x6f, 0xff, 0xf5, 0x6f, 0xff, + 0xf5, 0x6f, 0xff, 0xf5, 0x6f, 0xff, 0xf5, 0x6f, + 0xff, 0xf5, 0x6f, 0xff, 0xf5, 0x6f, 0xff, 0xf5, + 0x6f, 0xff, 0xf5, 0x6f, 0xff, 0xf5, 0x6f, 0xff, + 0xf5, 0x6f, 0xff, 0xf5, 0x6f, 0xff, 0xf5, 0x6f, + 0xff, 0xf5, 0x6f, 0xff, 0xf5, 0x6f, 0xff, 0xf5, + 0x6f, 0xff, 0xf5, 0x6f, 0xff, 0xf5, 0x6f, 0xff, + 0xf5, 0x6f, 0xff, 0xf5, 0x6f, 0xff, 0xf5, 0x6f, + 0xff, 0xf5, 0x6f, 0xff, 0xf5, 0x6f, 0xff, 0xf5, + 0x6f, 0xff, 0xf5, 0x6f, 0xff, 0xf5, 0x6f, 0xff, + 0xf5, 0x6f, 0xff, 0xf5, 0x6f, 0xff, 0xf5, 0x6f, + 0xff, 0xf5, 0x6f, 0xff, 0xf5, 0x6f, 0xff, 0xf5, + 0x6f, 0xff, 0xf5, 0x6f, 0xff, 0xf5, 0x6f, 0xff, + 0xf5, 0x6f, 0xff, 0xf5, + + /* U+004A "J" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x13, 0x7a, + 0xca, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xf1, 0x8f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0x7, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf0, 0x6f, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xfd, + 0x2, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0x90, 0xe, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xf5, 0x0, 0x8f, 0xff, + 0xff, 0x60, 0x0, 0x3, 0xcf, 0xff, 0xff, 0x0, + 0x1, 0xff, 0xff, 0xff, 0xfd, 0xdf, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x2, 0x9f, 0xff, 0xff, 0xff, 0xfa, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x67, 0x76, + 0x30, 0x0, 0x0, 0x0, 0x0, + + /* U+004B "K" */ + 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xe3, 0x5, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xe2, 0x0, 0x5f, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xe2, 0x0, 0x5, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x5f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xd2, 0x0, 0x0, 0x5, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xd1, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xd1, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xc1, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xc1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0x60, 0x0, 0x4f, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf6, 0x0, 0x4f, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0x60, 0x4f, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xf6, 0x4f, 0xff, 0xff, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xff, 0xff, 0x83, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xff, 0x80, 0x8, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0x80, 0x0, 0xc, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x40, 0x0, + 0x5, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xfe, 0x10, 0x0, + 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xfb, 0x0, 0x5, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xf7, 0x0, 0x5f, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0xf3, 0x5, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xd0, + + /* U+004C "L" */ + 0x3f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfa, 0x44, + 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x40, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf2, 0x3f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf2, 0x3f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + + /* U+004D "M" */ + 0x3f, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xe3, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xfe, 0x3f, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0xe3, 0xff, 0xff, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xfe, 0x3f, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0xe3, + 0xff, 0xff, 0xef, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0xfe, 0x3f, 0xff, 0xf9, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xcf, 0xff, 0xe3, 0xff, 0xff, 0x5e, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xca, 0xff, 0xfe, 0x3f, 0xff, 0xf5, 0x9f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf7, 0xaf, 0xff, 0xe3, 0xff, 0xff, + 0x54, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x1a, 0xff, 0xfe, 0x3f, + 0xff, 0xf5, 0xe, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xb0, 0xaf, 0xff, + 0xe3, 0xff, 0xff, 0x50, 0x9f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf6, 0xa, + 0xff, 0xfe, 0x3f, 0xff, 0xf5, 0x4, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x10, 0xaf, 0xff, 0xe3, 0xff, 0xff, 0x50, 0xe, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xb0, 0xa, 0xff, 0xfe, 0x3f, 0xff, 0xf5, + 0x0, 0x9f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xf5, 0x0, 0xaf, 0xff, 0xe3, 0xff, + 0xff, 0x50, 0x4, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x0, 0xa, 0xff, 0xfe, + 0x3f, 0xff, 0xf5, 0x0, 0xe, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xa0, 0x0, 0xaf, + 0xff, 0xe3, 0xff, 0xff, 0x50, 0x0, 0x9f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf5, 0x0, + 0xa, 0xff, 0xfe, 0x3f, 0xff, 0xf5, 0x0, 0x3, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x0, 0x0, 0xaf, 0xff, 0xe3, 0xff, 0xff, 0x50, + 0x0, 0xe, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xa0, 0x0, 0xa, 0xff, 0xfe, 0x3f, 0xff, + 0xf5, 0x0, 0x0, 0x9f, 0xff, 0xb0, 0x0, 0x0, + 0x7, 0xff, 0xf4, 0x0, 0x0, 0xaf, 0xff, 0xe3, + 0xff, 0xff, 0x50, 0x0, 0x3, 0xff, 0xff, 0x0, + 0x0, 0x0, 0xdf, 0xfe, 0x0, 0x0, 0xa, 0xff, + 0xfe, 0x3f, 0xff, 0xf5, 0x0, 0x0, 0xe, 0xff, + 0xf5, 0x0, 0x0, 0x2f, 0xff, 0x90, 0x0, 0x0, + 0xaf, 0xff, 0xe3, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x8f, 0xff, 0xb0, 0x0, 0x8, 0xff, 0xf4, 0x0, + 0x0, 0xa, 0xff, 0xfe, 0x3f, 0xff, 0xf5, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x0, 0x0, 0xdf, 0xfe, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xe3, 0xff, 0xff, + 0x50, 0x0, 0x0, 0xd, 0xff, 0xf5, 0x0, 0x3f, + 0xff, 0x90, 0x0, 0x0, 0xa, 0xff, 0xfe, 0x3f, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xa0, + 0x8, 0xff, 0xf3, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xe3, 0xff, 0xff, 0x50, 0x0, 0x0, 0x3, 0xff, + 0xff, 0x0, 0xdf, 0xfe, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfe, 0x3f, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xf5, 0x3f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xe3, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xa8, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xfe, 0x3f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xdf, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xe3, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, + 0x3f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xe3, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xfe, 0x3f, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xe3, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, + + /* U+004E "N" */ + 0xf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf2, 0xf, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf2, 0xf, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xf2, 0xf, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xf2, 0xf, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xf2, 0xf, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xf2, 0xf, 0xff, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xf2, 0xf, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf2, + 0xf, 0xff, 0xf9, 0xef, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf2, 0xf, + 0xff, 0xf8, 0x4f, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf2, 0xf, 0xff, + 0xf8, 0xa, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xf2, 0xf, 0xff, 0xf8, + 0x1, 0xef, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xf2, 0xf, 0xff, 0xf8, 0x0, + 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xf2, 0xf, 0xff, 0xf8, 0x0, 0xa, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xf2, 0xf, 0xff, 0xf8, 0x0, 0x1, 0xef, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xf2, 0xf, 0xff, 0xf8, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf2, + 0xf, 0xff, 0xf8, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf2, 0xf, + 0xff, 0xf8, 0x0, 0x0, 0x1, 0xef, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf2, 0xf, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x6f, 0xff, 0xf2, 0xf, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x6f, 0xff, 0xf2, 0xf, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xf7, 0x0, 0x0, + 0x6f, 0xff, 0xf2, 0xf, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x6f, + 0xff, 0xf2, 0xf, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xc0, 0x0, 0x6f, 0xff, + 0xf2, 0xf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xf7, 0x0, 0x6f, 0xff, 0xf2, + 0xf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0x20, 0x6f, 0xff, 0xf2, 0xf, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xc0, 0x6f, 0xff, 0xf2, 0xf, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xff, 0xf6, 0x6f, 0xff, 0xf2, 0xf, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0x8f, 0xff, 0xf2, 0xf, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xff, 0xf2, 0xf, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, + 0xff, 0xf2, 0xf, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0xf2, 0xf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xf2, + 0xf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xf2, 0xf, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf2, 0xf, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xf2, 0xf, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xf2, + + /* U+004F "O" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x46, + 0x77, 0x76, 0x41, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x8d, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x82, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2b, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xfd, 0xba, 0xcd, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xfa, 0x50, 0x0, + 0x0, 0x0, 0x5b, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xc3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xdf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xfe, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xf7, 0x0, 0x1, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xe0, + 0x0, 0x6f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0x50, 0xb, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xfa, 0x0, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xf0, 0x3f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x26, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf5, + 0x7f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0x79, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xf8, 0xaf, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0x8a, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf8, 0x9f, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x88, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xf7, 0x6f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0x53, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xf2, 0xf, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0x0, 0xbf, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xb0, 0x6, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf6, + 0x0, 0xf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xfe, 0x0, 0x0, 0x8f, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0x80, 0x0, 0x1, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xfb, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3c, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0x94, 0x0, + 0x0, 0x0, 0x4, 0xaf, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xff, 0xcb, 0xab, 0xdf, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xa1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x28, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xd8, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x67, + 0x77, 0x64, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+0050 "P" */ + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0xca, 0x73, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x60, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x2f, 0xff, 0xfb, 0x44, 0x44, 0x44, + 0x44, 0x45, 0x56, 0x8b, 0xff, 0xff, 0xff, 0x80, + 0x2, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xdf, 0xff, 0xff, 0x20, 0x2f, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xf8, 0x2, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xd0, 0x2f, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0x2, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xf1, 0x2f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x22, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf1, 0x2f, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0x2, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xb0, 0x2f, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xf7, 0x2, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xdf, 0xff, 0xff, 0x10, + 0x2f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x13, 0x6b, 0xff, 0xff, 0xff, 0x70, 0x2, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x2f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc1, 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0xb6, 0x10, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xb5, 0x55, 0x55, 0x55, 0x54, + 0x44, 0x21, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0051 "Q" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x46, + 0x77, 0x65, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x28, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xd7, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xfd, + 0xba, 0xcd, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, + 0xa5, 0x0, 0x0, 0x0, 0x4, 0xaf, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xc3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xcf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0x70, 0x0, 0x0, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xe0, 0x0, 0x6, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf5, 0x0, + 0xb, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xfa, 0x0, 0xf, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xfe, 0x0, 0x3f, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0x20, 0x6f, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x40, + 0x8f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0x70, 0x9f, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0x80, 0xaf, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0x80, 0xaf, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x80, + 0x9f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0x80, 0x8f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0x70, 0x6f, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0x50, 0x3f, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0x20, + 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0x0, 0xb, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xfa, 0x0, 0x6, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf5, 0x0, 0x0, 0xef, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7d, + 0x81, 0x0, 0x0, 0x3, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x7f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xa1, 0x0, 0xd, 0xff, 0xff, + 0x80, 0x0, 0x0, 0xe, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x60, 0xaf, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x2, 0xbf, 0xff, 0xff, + 0xfd, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xb2, 0x0, 0x0, 0x0, 0x0, + 0x7e, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0x94, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xff, 0xfc, 0xba, 0xbd, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3b, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf9, 0x8f, 0xff, 0xff, 0xe6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x39, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xc6, 0x10, 0x3, 0xef, 0xff, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x46, 0x77, 0x65, 0x30, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2a, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x28, 0x0, + + /* U+0052 "R" */ + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xed, 0xa7, 0x30, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x50, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x36, 0xcf, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x10, 0x0, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0x50, 0x0, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x80, 0x0, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x90, 0x0, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x90, 0x0, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x70, 0x0, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x30, 0x0, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, 0x0, 0x0, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2b, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0xff, 0xff, 0xc2, 0x22, 0x22, 0x22, 0x22, 0x23, + 0x35, 0x8c, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x10, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xa2, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe7, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x1, 0x37, 0xdf, + 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0x20, 0x0, 0x0, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x10, 0x0, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xb0, 0x0, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf5, 0x0, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xfe, 0x0, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x90, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf3, + + /* U+0053 "S" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x14, 0x67, 0x76, + 0x53, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x29, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xd7, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x4, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd2, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, + 0xdc, 0xcd, 0xef, 0xff, 0xff, 0xff, 0xe2, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xff, 0x94, 0x0, 0x0, + 0x0, 0x15, 0xcf, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x8f, 0xff, 0xfd, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0x70, 0x0, 0xe, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xfd, 0x0, 0x3, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf3, 0x0, 0x4f, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0x60, 0x5, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf8, 0x0, + 0x4f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x77, 0x65, 0x20, 0x1, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xc2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfb, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xfb, + 0x73, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xc8, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x17, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x38, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x14, 0x8c, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x59, 0xef, 0xff, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4c, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0x77, 0xbd, 0xec, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xfa, 0xaf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xb8, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xfa, 0x4f, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0x80, 0xef, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xf5, 0x8, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0x0, 0xe, 0xff, 0xff, 0xf9, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5e, 0xff, 0xff, 0x80, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0xa5, 0x10, 0x0, + 0x0, 0x26, 0xcf, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xed, 0xde, 0xff, + 0xff, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x5e, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd2, 0x0, 0x0, 0x0, 0x0, 0x1a, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x7c, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd7, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x35, 0x67, + 0x76, 0x54, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0054 "T" */ + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf7, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x7e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf7, 0x44, 0x44, 0x44, 0x44, 0x44, 0x46, + 0xff, 0xff, 0xb4, 0x44, 0x44, 0x44, 0x44, 0x44, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0055 "U" */ + 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf2, 0xf, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf2, 0xf, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xf2, 0xf, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xf2, 0xf, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xf2, 0xf, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xf2, 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xf2, 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf2, + 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf2, 0xf, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf2, 0xf, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xf2, 0xf, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xf2, 0xf, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xf2, 0xf, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xf2, 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xf2, 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf2, + 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf2, 0xf, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf2, 0xf, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xf2, 0xf, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xf2, 0xf, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xf1, 0xf, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xf1, 0xf, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xf1, 0xe, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf0, + 0xd, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xe0, 0xa, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xd0, 0x8, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xa0, 0x4, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0x70, 0x0, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0x20, 0x0, 0xaf, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xfd, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xc2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1a, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xa4, 0x0, + 0x0, 0x1, 0x49, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x1, 0xdf, 0xff, 0xff, 0xff, 0xfe, 0xde, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, + 0x0, 0x2d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x8d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc7, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x14, 0x57, 0x77, 0x65, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+0056 "V" */ + 0x8f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xc2, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xf6, 0xc, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0x0, 0x6f, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x90, 0x0, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xf3, 0x0, 0xa, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xfd, 0x0, 0x0, 0x4f, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0x70, 0x0, 0x0, 0xdf, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xf1, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xf5, 0x0, 0x0, 0x2, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xb0, 0x0, 0x0, 0x8f, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0x10, 0x0, 0xe, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf6, 0x0, 0x4, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xc0, 0x0, 0xaf, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0x20, 0xe, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf7, 0x4, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xc0, 0x9f, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x1e, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfa, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0057 "W" */ + 0x5f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x61, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf1, 0xd, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xfd, 0x0, 0x9f, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0x90, 0x4, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xfe, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xf4, 0x0, 0xf, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x6f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0x0, 0x0, 0xcf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xf0, 0xef, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xc0, 0x0, 0x8, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfb, + 0xa, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xf7, 0x0, 0x0, 0x3f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x70, + 0x6f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0x30, 0x0, 0x0, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf2, 0x2, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xe0, 0x0, 0x0, 0xb, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xfe, 0x0, 0xd, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xa0, 0x0, 0x9f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x3, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf5, 0x0, 0x5, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0x10, 0x0, 0xf, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x8, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xc0, 0x0, 0x0, 0xcf, 0xff, + 0x80, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xf8, 0x0, 0x0, 0x7, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x30, 0x0, 0x0, 0x3f, 0xff, 0xf1, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x60, 0x0, 0x0, 0x2f, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x60, + 0x0, 0x0, 0x7f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xfa, 0x0, 0x0, 0x6, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfa, 0x0, + 0x0, 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xd0, 0x0, 0x0, 0xbf, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xe0, 0x0, + 0x0, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0x10, 0x0, 0xf, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x30, 0x0, + 0x3f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xf5, 0x0, 0x4, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf7, 0x0, 0x7, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0x80, 0x0, 0x8f, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xb0, 0x0, 0xbf, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xfc, 0x0, 0xd, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xfe, 0x0, 0xe, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf0, 0x1, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf2, 0x2, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x30, 0x5f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x60, 0x6f, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf7, 0x9, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf9, 0xa, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xa0, 0xdf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xc0, 0xef, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xfd, + 0x1f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0x1f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf6, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf7, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xcf, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xdf, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0058 "X" */ + 0x0, 0xcf, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xfb, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xe1, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0x30, 0x0, 0x4, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xd0, 0x0, 0x1e, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xf8, 0x0, 0xbf, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0x36, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xce, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x3d, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf8, 0x4, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xd0, 0x0, + 0x9f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x20, + 0x0, 0xd, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xf6, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x80, + 0x0, 0x1, 0xdf, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xf4, 0x0, 0xa, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xfe, 0x10, 0x6f, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xa0, + + /* U+0059 "Y" */ + 0x8f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0x90, 0xdf, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xd0, 0x3, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xf3, 0x0, 0x8, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xf8, 0x0, 0x0, 0xd, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x1f, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xfe, 0x10, 0x0, 0xb, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf9, 0x0, 0x5, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf3, 0x0, + 0xef, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xc0, + 0x8f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0x8f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+005A "Z" */ + 0x0, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0xf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0xf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x4, 0x44, 0x44, + 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x8f, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfd, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2e, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xc4, 0x44, 0x44, 0x44, + 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x40, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x1f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x1f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf3, 0x1f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf3, + + /* U+005B "[" */ + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xa, 0xff, 0xff, + 0xff, 0xff, 0xf0, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xa, 0xff, 0xfe, 0xbb, 0xbb, 0xb0, 0xaf, 0xff, + 0xb0, 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0xa, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, + 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xb0, 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0xa, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, + 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xb0, 0x0, 0x0, 0xa, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, 0x0, + 0xa, 0xff, 0xfb, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xb0, 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0xa, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, + 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xb0, 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0xa, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, + 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xb0, 0x0, 0x0, 0xa, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, 0x0, + 0xa, 0xff, 0xfb, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xb0, 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0xa, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, + 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xeb, 0xbb, 0xbb, 0xa, 0xff, 0xff, 0xff, + 0xff, 0xf0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xa, + 0xff, 0xff, 0xff, 0xff, 0xf0, + + /* U+005C "\\" */ + 0x78, 0x84, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xfc, + + /* U+005D "]" */ + 0x2f, 0xff, 0xff, 0xff, 0xff, 0x92, 0xff, 0xff, + 0xff, 0xff, 0xf9, 0x2f, 0xff, 0xff, 0xff, 0xff, + 0x91, 0xbb, 0xbb, 0xbf, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x90, 0x0, 0x0, 0xd, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x90, 0x0, + 0x0, 0xd, 0xff, 0xf9, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x90, 0x0, 0x0, 0xd, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x90, 0x0, 0x0, 0xd, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x90, + 0x0, 0x0, 0xd, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x90, 0x0, 0x0, 0xd, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x90, 0x0, 0x0, + 0xd, 0xff, 0xf9, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x90, 0x0, 0x0, 0xd, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x90, 0x0, 0x0, 0xd, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x90, 0x0, + 0x0, 0xd, 0xff, 0xf9, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x90, 0x0, 0x0, 0xd, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x90, 0x0, 0x0, 0xd, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x90, + 0x0, 0x0, 0xd, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x90, 0x0, 0x0, 0xd, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x90, 0x0, 0x0, + 0xd, 0xff, 0xf9, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x90, 0x0, 0x0, 0xd, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x90, 0x0, 0x0, 0xd, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x90, 0x0, + 0x0, 0xd, 0xff, 0xf9, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x90, 0x0, 0x0, 0xd, 0xff, 0xf9, 0x1b, + 0xbb, 0xbb, 0xff, 0xff, 0x92, 0xff, 0xff, 0xff, + 0xff, 0xf9, 0x2f, 0xff, 0xff, 0xff, 0xff, 0x92, + 0xff, 0xff, 0xff, 0xff, 0xf9, + + /* U+005E "^" */ + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xaf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x2b, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xfb, 0x5, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf5, 0x0, 0xef, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xe0, + 0x0, 0x8f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0x80, 0x0, 0x2f, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0x20, 0x0, 0xb, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfc, + 0x0, 0x0, 0x5, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xf6, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x50, 0x0, 0x0, 0x5f, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xc0, 0x0, 0x0, 0xcf, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf3, 0x0, + 0x2, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xf9, 0x0, 0x9, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0x10, 0x1f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x70, 0x7f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xe0, + + /* U+005F "_" */ + 0x13, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x30, 0x4f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0x4f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf1, 0x4f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf1, + + /* U+0060 "`" */ + 0x6f, 0xff, 0xff, 0x40, 0x0, 0xa, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0xcf, 0xff, 0xf3, 0x0, 0x0, + 0x1e, 0xff, 0xfb, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x6f, 0xff, 0xa0, 0x0, 0x0, + 0x9, 0xff, 0xf2, + + /* U+0061 "a" */ + 0x0, 0x0, 0x0, 0x0, 0x2, 0x56, 0x77, 0x76, + 0x41, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0x9e, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x60, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc2, 0x0, 0x0, 0x0, 0x1c, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe1, 0x0, 0x0, 0xb, 0xff, 0xff, 0xfa, 0x64, + 0x33, 0x58, 0xdf, 0xff, 0xff, 0x90, 0x0, 0x5, + 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xfe, 0x0, 0x0, 0xcf, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf2, 0x0, + 0x1f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0x40, 0x2, 0x9c, 0xef, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x46, 0x9c, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x3, 0x8b, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x1, 0x8e, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xb7, + 0x2f, 0xff, 0xf6, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xfd, 0xa7, 0x52, 0x0, 0x0, 0xff, 0xff, 0x60, + 0x3, 0xff, 0xff, 0xfc, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf6, 0x0, 0xaf, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0x60, 0xe, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xf6, 0x0, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0x60, 0xf, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xf6, 0x0, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xcf, + 0xff, 0xff, 0x70, 0xb, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x3, 0xdf, 0xff, 0xff, 0xf8, 0x0, + 0x4f, 0xff, 0xff, 0xc5, 0x10, 0x2, 0x5b, 0xff, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x58, 0xff, 0xfd, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfb, 0x20, 0x5f, 0xff, 0xf1, 0x0, 0x0, 0x4b, + 0xff, 0xff, 0xff, 0xfe, 0xa3, 0x0, 0x0, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x1, 0x46, 0x76, 0x53, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0062 "b" */ + 0xaf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfc, 0x0, 0x0, 0x25, 0x76, 0x52, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xc0, 0x5, 0xdf, + 0xff, 0xff, 0xfd, 0x70, 0x0, 0x0, 0xa, 0xff, + 0xfc, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd3, + 0x0, 0x0, 0xaf, 0xff, 0xcb, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf3, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xfe, 0x84, 0x34, 0x8e, 0xff, 0xff, 0xf2, + 0x0, 0xaf, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xc0, 0xa, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x50, + 0xaf, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xfc, 0xa, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf2, 0xaf, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0x5a, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf9, 0xaf, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xba, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xfc, 0xaf, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xda, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfc, 0xaf, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xba, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xfa, 0xaf, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x7a, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf4, 0xaf, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xa, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x90, 0xaf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xf2, 0xa, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x1, 0xcf, 0xff, 0xf8, 0x0, + 0xaf, 0xff, 0xef, 0xff, 0xc6, 0x33, 0x49, 0xff, + 0xff, 0xfc, 0x0, 0xa, 0xff, 0xf7, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x10, 0x0, 0xaf, + 0xff, 0x71, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0xa, 0xff, 0xf7, 0x0, 0x7e, 0xff, + 0xff, 0xff, 0xb4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0x67, 0x64, 0x10, 0x0, 0x0, + 0x0, 0x0, + + /* U+0063 "c" */ + 0x0, 0x0, 0x0, 0x0, 0x1, 0x46, 0x77, 0x52, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xcf, 0xff, 0xff, 0xff, 0xe8, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xfe, 0x95, 0x33, 0x5b, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xa1, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x10, + 0x0, 0x7f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0x70, 0x0, 0xef, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xc0, + 0x4, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xc0, 0x8, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x14, 0x10, 0x0, + 0xb, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0x64, 0x20, + 0x8, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf6, 0x4, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf3, + 0x0, 0xef, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xe0, 0x0, 0x7f, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x70, + 0x0, 0xd, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xfe, 0x10, 0x0, 0x3, 0xff, 0xff, + 0xfd, 0x74, 0x33, 0x6b, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x3, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xe4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xcf, 0xff, 0xff, 0xff, + 0xe7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x46, 0x77, 0x52, 0x0, 0x0, 0x0, 0x0, + + /* U+0064 "d" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x4, 0x57, 0x65, 0x10, 0x0, 0x1f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x2a, 0xff, 0xff, 0xff, 0xfb, + 0x20, 0x1f, 0xff, 0xf4, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf6, 0x1f, 0xff, 0xf4, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x7f, 0xff, 0xf4, 0x0, 0x6, 0xff, 0xff, + 0xfc, 0x74, 0x35, 0xaf, 0xff, 0xff, 0xff, 0xf4, + 0x0, 0x2f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x2, + 0xdf, 0xff, 0xff, 0xf4, 0x0, 0xaf, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xf4, + 0x1, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xf4, 0x6, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf4, + 0xa, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xf4, 0xe, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf4, + 0xf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf4, 0x1f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf4, + 0x2f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf4, 0x2f, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf4, + 0x1f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf4, 0xf, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf4, + 0xd, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf4, 0x9, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf4, + 0x5, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xf4, 0x0, 0xef, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf4, + 0x0, 0x8f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xf4, 0x0, 0xd, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x1, 0xcf, 0xff, 0xff, 0xf4, + 0x0, 0x3, 0xff, 0xff, 0xfd, 0x74, 0x34, 0x9f, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x7c, 0xff, 0xf4, + 0x0, 0x0, 0x4, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0xc, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x8, + 0xef, 0xff, 0xff, 0xfc, 0x40, 0xc, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x3, 0x57, 0x75, 0x20, + 0x0, 0x0, 0x0, 0x0, + + /* U+0065 "e" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x45, 0x77, 0x54, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4b, 0xff, 0xff, 0xff, 0xff, 0xb3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x10, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0x95, + 0x33, 0x59, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xfb, 0x10, 0x0, 0x0, 0x1, 0xaf, + 0xff, 0xf9, 0x0, 0x0, 0x5f, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf3, 0x0, + 0xc, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xa0, 0x3, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x0, 0x7f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xf4, 0xb, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0x80, 0xef, 0xff, 0xea, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaf, 0xff, 0xfa, 0xf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb0, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd0, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x65, 0x31, 0x0, 0x5f, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf8, 0x0, 0xef, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0x30, 0x7, + 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xb0, 0x0, 0xd, 0xff, 0xff, 0xd3, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xfb, 0x63, 0x34, 0x7d, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x3e, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x2c, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xbf, 0xff, 0xff, 0xff, 0xfe, 0x81, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x57, + 0x76, 0x52, 0x0, 0x0, 0x0, 0x0, + + /* U+0066 "f" */ + 0x0, 0x0, 0x0, 0x0, 0x14, 0x67, 0x75, 0x30, + 0x0, 0x0, 0x0, 0x1a, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x3, 0xef, 0xff, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xea, 0x9a, 0xc0, + 0x0, 0x0, 0x8f, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0x47, 0x77, 0xdf, 0xff, 0xd7, 0x77, 0x75, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, + + /* U+0067 "g" */ + 0x0, 0x0, 0x0, 0x0, 0x3, 0x57, 0x75, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2a, + 0xff, 0xff, 0xff, 0xfc, 0x40, 0x7, 0xff, 0xf9, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0x7, 0xff, 0xf9, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xb8, 0xff, 0xf9, + 0x0, 0x7, 0xff, 0xff, 0xfc, 0x74, 0x35, 0x9e, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x2f, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x1, 0xbf, 0xff, 0xff, 0xf9, + 0x0, 0xbf, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xf9, 0x2, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf9, + 0x8, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf9, 0xc, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf9, + 0xf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf9, 0x2f, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf9, + 0x3f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf9, 0x4f, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf9, + 0x4f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf9, 0x3f, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf9, + 0x1f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf9, 0xe, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf9, + 0xa, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf9, 0x5, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf9, + 0x0, 0xef, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xf9, 0x0, 0x6f, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, 0xff, 0xf9, + 0x0, 0xc, 0xff, 0xff, 0xe5, 0x0, 0x0, 0x17, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x1, 0xef, 0xff, + 0xff, 0xfc, 0xbd, 0xff, 0xff, 0xef, 0xff, 0xf8, + 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x3e, 0xff, 0xf8, 0x0, 0x0, 0x1, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xb2, 0xf, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x2, 0x7b, 0xdf, 0xfd, 0x94, + 0x0, 0xf, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf3, 0x5, 0xb9, 0x74, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf1, + 0x5, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xd0, 0x2, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x80, + 0x0, 0xdf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x4f, 0xff, 0xff, + 0xb7, 0x43, 0x35, 0x8d, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xe4, 0x0, 0x0, + 0x0, 0x0, 0x2, 0x9e, 0xff, 0xff, 0xff, 0xff, + 0xc6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x25, 0x67, 0x76, 0x41, 0x0, 0x0, 0x0, 0x0, + + /* U+0068 "h" */ + 0xaf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xc0, 0x0, 0x0, + 0x46, 0x76, 0x52, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xc0, 0x2, 0xaf, 0xff, 0xff, 0xff, 0xd6, 0x0, + 0x0, 0xaf, 0xff, 0xc0, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb1, 0x0, 0xaf, 0xff, 0xc9, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xfb, 0x76, 0x69, 0xff, 0xff, + 0xff, 0x50, 0xaf, 0xff, 0xff, 0xfb, 0x20, 0x0, + 0x0, 0x1b, 0xff, 0xff, 0xc0, 0xaf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf0, + 0xaf, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xf3, 0xaf, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf5, 0xaf, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf6, 0xaf, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf7, 0xaf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf7, 0xaf, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf7, 0xaf, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf7, 0xaf, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf7, + 0xaf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xf7, 0xaf, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xf7, 0xaf, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xf7, 0xaf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf7, 0xaf, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf7, 0xaf, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf7, 0xaf, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf7, 0xaf, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf7, + 0xaf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xf7, 0xaf, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xf7, 0xaf, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xf7, 0xaf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf7, + + /* U+0069 "i" */ + 0xaf, 0xff, 0xba, 0xff, 0xfb, 0xaf, 0xff, 0xba, + 0xff, 0xfb, 0xaf, 0xff, 0xb1, 0x22, 0x21, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xba, 0xff, 0xfb, 0xaf, 0xff, + 0xba, 0xff, 0xfb, 0xaf, 0xff, 0xba, 0xff, 0xfb, + 0xaf, 0xff, 0xba, 0xff, 0xfb, 0xaf, 0xff, 0xba, + 0xff, 0xfb, 0xaf, 0xff, 0xba, 0xff, 0xfb, 0xaf, + 0xff, 0xba, 0xff, 0xfb, 0xaf, 0xff, 0xba, 0xff, + 0xfb, 0xaf, 0xff, 0xba, 0xff, 0xfb, 0xaf, 0xff, + 0xba, 0xff, 0xfb, 0xaf, 0xff, 0xba, 0xff, 0xfb, + 0xaf, 0xff, 0xba, 0xff, 0xfb, 0xaf, 0xff, 0xba, + 0xff, 0xfb, + + /* U+006A "j" */ + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xc0, 0x0, 0x0, + 0xa, 0xff, 0xfc, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xc0, 0x0, 0x0, 0xa, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xc0, 0x0, 0x0, 0x1, 0x33, + 0x32, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xc0, 0x0, 0x0, 0xa, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xc0, + 0x0, 0x0, 0xa, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xc0, 0x0, 0x0, 0xa, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xc0, 0x0, 0x0, + 0xa, 0xff, 0xfc, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xc0, 0x0, 0x0, 0xa, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xc0, 0x0, 0x0, 0xa, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xc0, 0x0, + 0x0, 0xa, 0xff, 0xfc, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xc0, 0x0, 0x0, 0xa, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xc0, 0x0, 0x0, 0xa, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xc0, + 0x0, 0x0, 0xa, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xc0, 0x0, 0x0, 0xa, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xc0, 0x0, 0x0, + 0xa, 0xff, 0xfc, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xc0, 0x0, 0x0, 0xa, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xc0, 0x0, 0x0, 0xa, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, + 0x0, 0xb, 0xff, 0xfa, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x80, 0x0, 0x0, 0x3f, 0xff, 0xf6, 0x5, + 0x97, 0x8e, 0xff, 0xff, 0x20, 0xaf, 0xff, 0xff, + 0xff, 0xc0, 0xd, 0xff, 0xff, 0xff, 0xf3, 0x1, + 0xff, 0xff, 0xff, 0xd3, 0x0, 0x2, 0x57, 0x76, + 0x30, 0x0, 0x0, + + /* U+006B "k" */ + 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0x40, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xf4, 0x0, 0xaf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0x40, 0x0, 0xaf, + 0xff, 0xb0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0x30, 0x0, 0x0, 0xaf, 0xff, 0xb0, + 0x0, 0x5, 0xff, 0xff, 0xe3, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xb0, 0x0, 0x4f, 0xff, 0xfe, 0x30, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x4, 0xff, + 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xb0, 0x4f, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xb4, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xef, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xfe, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xd1, 0xaf, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xfd, 0x10, 0x1e, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xd1, 0x0, 0x6, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xb0, 0x0, 0x0, 0xbf, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xc0, 0x0, 0x0, 0xaf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf7, + 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x20, 0x0, 0xaf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xc0, 0x0, + 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf7, 0x0, 0xaf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0x20, 0xaf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xc0, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xf7, + + /* U+006C "l" */ + 0xbf, 0xff, 0xbb, 0xff, 0xfb, 0xbf, 0xff, 0xbb, + 0xff, 0xfb, 0xbf, 0xff, 0xbb, 0xff, 0xfb, 0xbf, + 0xff, 0xbb, 0xff, 0xfb, 0xbf, 0xff, 0xbb, 0xff, + 0xfb, 0xbf, 0xff, 0xbb, 0xff, 0xfb, 0xbf, 0xff, + 0xbb, 0xff, 0xfb, 0xbf, 0xff, 0xbb, 0xff, 0xfb, + 0xbf, 0xff, 0xbb, 0xff, 0xfb, 0xbf, 0xff, 0xbb, + 0xff, 0xfb, 0xbf, 0xff, 0xbb, 0xff, 0xfb, 0xbf, + 0xff, 0xbb, 0xff, 0xfb, 0xbf, 0xff, 0xbb, 0xff, + 0xfb, 0xbf, 0xff, 0xbb, 0xff, 0xfb, 0xbf, 0xff, + 0xbb, 0xff, 0xfb, 0xbf, 0xff, 0xbb, 0xff, 0xfb, + 0xbf, 0xff, 0xbb, 0xff, 0xfb, 0xbf, 0xff, 0xbb, + 0xff, 0xfb, + + /* U+006D "m" */ + 0x0, 0x0, 0x0, 0x0, 0x2, 0x57, 0x76, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x14, 0x77, 0x64, 0x10, + 0x0, 0x0, 0xbf, 0xff, 0x30, 0x5, 0xdf, 0xff, + 0xff, 0xfe, 0x70, 0x0, 0x0, 0x2a, 0xff, 0xff, + 0xff, 0xfa, 0x20, 0x0, 0xbf, 0xff, 0x30, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe3, 0x0, 0xbf, 0xff, + 0x3c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x10, + 0xbf, 0xff, 0xcf, 0xff, 0xe9, 0x66, 0x9e, 0xff, + 0xff, 0xf5, 0xff, 0xff, 0xa7, 0x67, 0xcf, 0xff, + 0xff, 0x80, 0xbf, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x1, 0xcf, 0xff, 0xff, 0xff, 0xa1, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xe0, 0xbf, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf2, 0xbf, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf4, + 0xbf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xf5, 0xbf, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf6, 0xbf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf6, 0xbf, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf6, + 0xbf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf6, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf6, 0xbf, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf6, 0xbf, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf6, + 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf6, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf6, 0xbf, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf6, 0xbf, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf6, + 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf6, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf6, 0xbf, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf6, 0xbf, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf6, + 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf6, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf6, 0xbf, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf6, + + /* U+006E "n" */ + 0x0, 0x0, 0x0, 0x0, 0x1, 0x46, 0x77, 0x52, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0x50, 0x3, 0xbf, + 0xff, 0xff, 0xff, 0xd5, 0x0, 0x0, 0x9f, 0xff, + 0x50, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x9f, 0xff, 0x59, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x0, 0x9f, 0xff, 0xbf, 0xff, + 0xfb, 0x76, 0x79, 0xef, 0xff, 0xff, 0x60, 0x9f, + 0xff, 0xff, 0xfa, 0x10, 0x0, 0x0, 0x1b, 0xff, + 0xff, 0xd0, 0x9f, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xf1, 0x9f, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf4, + 0x9f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf5, 0x9f, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf6, 0x9f, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf7, 0x9f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf7, 0x9f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf7, 0x9f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf7, 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf7, 0x9f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf7, + 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf7, 0x9f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf7, 0x9f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf7, 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf7, 0x9f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf7, 0x9f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf7, 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf7, 0x9f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf7, + 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf7, 0x9f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf7, 0x9f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf7, + + /* U+006F "o" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x46, 0x77, 0x54, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xbf, 0xff, 0xff, 0xff, 0xfb, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe2, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xa5, 0x34, 0x6a, 0xff, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xb1, 0x0, 0x0, + 0x0, 0x2c, 0xff, 0xff, 0xc0, 0x0, 0x0, 0xaf, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xf6, 0x0, 0x2, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfd, 0x0, + 0x7, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0x40, 0xb, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x80, 0xf, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xc0, 0x1f, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xe0, 0x2f, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xf0, 0x3f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf0, 0x3f, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xf0, 0x2f, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xe0, + 0x1f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xd0, 0xf, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xb0, 0xb, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x70, 0x7, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0x30, 0x1, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfd, + 0x0, 0x0, 0xaf, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xf6, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xa1, 0x0, 0x0, 0x0, 0x2c, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0x95, 0x33, 0x5a, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xcf, 0xff, + 0xff, 0xff, 0xfb, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x46, 0x77, 0x54, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0070 "p" */ + 0x0, 0x0, 0x0, 0x0, 0x3, 0x57, 0x75, 0x30, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf6, 0x0, 0x6d, + 0xff, 0xff, 0xff, 0xe8, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x61, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x40, 0x0, 0x9, 0xff, 0xf6, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, 0x9f, 0xff, + 0xef, 0xff, 0xd6, 0x10, 0x15, 0xcf, 0xff, 0xff, + 0x20, 0x9, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xfc, 0x0, 0x9f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf5, + 0x9, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xc0, 0x9f, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x29, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf6, 0x9f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xa9, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xfc, 0x9f, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xd9, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xfe, 0x9f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xd9, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xfc, + 0x9f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xb9, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf8, 0x9f, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0x49, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf0, 0x9f, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xf9, 0x9, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0x30, 0x9f, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x2c, 0xff, 0xff, 0x90, + 0x9, 0xff, 0xff, 0xff, 0xfc, 0x64, 0x34, 0x9f, + 0xff, 0xff, 0xd0, 0x0, 0x9f, 0xff, 0xdd, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd1, 0x0, 0x9, + 0xff, 0xfc, 0x1c, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xb1, 0x0, 0x0, 0x9f, 0xff, 0xc0, 0x7, 0xef, + 0xff, 0xff, 0xfc, 0x50, 0x0, 0x0, 0x9, 0xff, + 0xfc, 0x0, 0x0, 0x36, 0x76, 0x41, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0071 "q" */ + 0x0, 0x0, 0x0, 0x0, 0x3, 0x57, 0x75, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x19, + 0xef, 0xff, 0xff, 0xfb, 0x30, 0xa, 0xff, 0xf5, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf7, 0xa, 0xff, 0xf5, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x7a, 0xff, 0xf5, + 0x0, 0x6, 0xff, 0xff, 0xfa, 0x41, 0x12, 0x7e, + 0xff, 0xfd, 0xff, 0xf5, 0x0, 0x1f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x1, 0xcf, 0xff, 0xff, 0xf5, + 0x0, 0xaf, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xf5, 0x1, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf5, + 0x6, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xf5, 0xa, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf5, + 0xd, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf5, 0xf, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf5, + 0xf, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf5, 0x1f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf5, + 0x1f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf5, 0xf, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf5, + 0xf, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf5, 0xb, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf5, + 0x8, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf5, 0x3, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf5, + 0x0, 0xdf, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xf5, 0x0, 0x5f, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf5, + 0x0, 0xb, 0xff, 0xff, 0x90, 0x0, 0x0, 0x1, + 0xbf, 0xff, 0xff, 0xf5, 0x0, 0x2, 0xef, 0xff, + 0xfe, 0x84, 0x34, 0x8e, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xaf, 0xff, 0xf5, 0x0, 0x0, 0x2, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0x1f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x7, 0xdf, 0xff, 0xff, 0xfc, + 0x40, 0x1f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x57, 0x76, 0x20, 0x0, 0x1f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf5, + + /* U+0072 "r" */ + 0x0, 0x0, 0x0, 0x0, 0x47, 0x74, 0x0, 0xc, + 0xff, 0xf3, 0x2, 0xdf, 0xff, 0xff, 0x91, 0xcf, + 0xff, 0x32, 0xef, 0xff, 0xff, 0xff, 0x1c, 0xff, + 0xf3, 0xdf, 0xff, 0xff, 0xff, 0xb0, 0xcf, 0xff, + 0xaf, 0xff, 0xff, 0xff, 0xf6, 0xc, 0xff, 0xff, + 0xff, 0xa4, 0x24, 0x7e, 0x10, 0xcf, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+0073 "s" */ + 0x0, 0x0, 0x0, 0x1, 0x56, 0x77, 0x64, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6d, 0xff, + 0xff, 0xff, 0xff, 0xc7, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x40, 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0xdf, + 0xff, 0xfd, 0x74, 0x33, 0x48, 0xef, 0xff, 0xff, + 0x10, 0x0, 0x4f, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf7, 0x0, 0x9, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xc0, + 0x0, 0xbf, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xfe, 0x0, 0xb, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x14, 0x20, 0x0, 0x0, + 0x8f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xa4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0xff, 0xb7, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe9, 0x40, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6b, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x59, 0xdf, 0xff, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x16, 0xbf, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x19, 0xff, 0xff, 0xd0, 0x0, + 0x14, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0x5, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf0, 0x2f, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0x0, 0xdf, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xb0, 0x5, 0xff, 0xff, + 0xd2, 0x0, 0x0, 0x0, 0x1, 0xcf, 0xff, 0xf5, + 0x0, 0xb, 0xff, 0xff, 0xfa, 0x63, 0x23, 0x59, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x1d, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x10, 0x0, + 0x0, 0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0x10, 0x0, 0x0, 0x0, 0x4, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xb4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0x57, 0x77, 0x63, 0x0, 0x0, + 0x0, 0x0, + + /* U+0074 "t" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1a, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x60, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd0, 0x3f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd0, 0x3f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd0, 0x17, 0x77, 0xff, 0xff, 0xb7, + 0x77, 0x60, 0x0, 0x0, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xfe, 0xbb, 0xb0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x1e, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x2, + 0xcf, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x2, + 0x67, 0x76, 0x41, + + /* U+0075 "u" */ + 0xbf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xf5, 0xbf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf5, 0xbf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xf5, 0xbf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf5, 0xbf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf5, 0xbf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xf5, 0xbf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xf5, 0xbf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf5, + 0xbf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xf5, 0xbf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf5, 0xbf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xf5, 0xbf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf5, 0xbf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf5, 0xbf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xf5, 0xbf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xf5, 0xbf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf5, + 0xbf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xf5, 0xaf, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf5, 0x9f, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xf5, 0x7f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xf5, 0x5f, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf5, 0x1f, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x2, 0xcf, 0xff, + 0xff, 0xf5, 0x9, 0xff, 0xff, 0xfd, 0x86, 0x67, + 0xbf, 0xff, 0xeb, 0xff, 0xf5, 0x1, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x39, 0xff, 0xf5, + 0x0, 0x2d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe3, + 0x9, 0xff, 0xf5, 0x0, 0x0, 0x7e, 0xff, 0xff, + 0xff, 0xe8, 0x0, 0x9, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x36, 0x77, 0x63, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+0076 "v" */ + 0x2f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0x30, 0xcf, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xd0, 0x6, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf7, 0x0, 0x1f, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0x10, 0x0, 0xaf, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xb0, 0x0, 0x4, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xf5, 0x0, 0x0, 0xe, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x90, 0x0, 0x0, 0x2, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0xef, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x4f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xfb, 0x0, 0x0, 0xa, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf1, + 0x0, 0x0, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x70, 0x0, 0x5f, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xfd, 0x0, 0xb, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf2, 0x1, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x70, 0x7f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfc, 0xc, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf3, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xcf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0077 "w" */ + 0x9f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xfa, 0x4f, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf5, 0xf, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf0, 0xb, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xb0, + 0x6, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x60, 0x1, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0x10, 0x0, 0xcf, 0xff, 0x90, + 0x0, 0x0, 0x0, 0xdf, 0xfe, 0xef, 0xff, 0x10, + 0x0, 0x0, 0x6, 0xff, 0xfc, 0x0, 0x0, 0x7f, + 0xff, 0xd0, 0x0, 0x0, 0x1, 0xff, 0xf9, 0xaf, + 0xff, 0x50, 0x0, 0x0, 0xa, 0xff, 0xf7, 0x0, + 0x0, 0x2f, 0xff, 0xf1, 0x0, 0x0, 0x6, 0xff, + 0xf5, 0x6f, 0xff, 0x90, 0x0, 0x0, 0xf, 0xff, + 0xf2, 0x0, 0x0, 0xd, 0xff, 0xf6, 0x0, 0x0, + 0xa, 0xff, 0xf1, 0x3f, 0xff, 0xe0, 0x0, 0x0, + 0x4f, 0xff, 0xd0, 0x0, 0x0, 0x8, 0xff, 0xfa, + 0x0, 0x0, 0xe, 0xff, 0xd0, 0xf, 0xff, 0xf2, + 0x0, 0x0, 0x9f, 0xff, 0x80, 0x0, 0x0, 0x4, + 0xff, 0xfe, 0x0, 0x0, 0x3f, 0xff, 0x90, 0xb, + 0xff, 0xf6, 0x0, 0x0, 0xdf, 0xff, 0x30, 0x0, + 0x0, 0x0, 0xef, 0xff, 0x30, 0x0, 0x7f, 0xff, + 0x40, 0x7, 0xff, 0xfa, 0x0, 0x2, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x70, 0x0, + 0xbf, 0xff, 0x0, 0x2, 0xff, 0xfe, 0x0, 0x7, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xc0, 0x0, 0xff, 0xfc, 0x0, 0x0, 0xef, 0xff, + 0x20, 0xc, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf0, 0x4, 0xff, 0xf8, 0x0, 0x0, + 0xaf, 0xff, 0x60, 0x1f, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf5, 0x8, 0xff, 0xf4, + 0x0, 0x0, 0x6f, 0xff, 0xa0, 0x5f, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf9, 0xc, + 0xff, 0xf0, 0x0, 0x0, 0x1f, 0xff, 0xe0, 0xaf, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xfd, 0xf, 0xff, 0xb0, 0x0, 0x0, 0xd, 0xff, + 0xf3, 0xef, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x6f, 0xff, 0x70, 0x0, 0x0, + 0x9, 0xff, 0xfb, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xef, 0xff, 0x30, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, + + /* U+0078 "x" */ + 0x9, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf9, 0x0, 0xd, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xfd, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x7f, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf8, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xf2, 0x0, 0x3, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xc0, 0x0, 0xdf, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0x70, 0x9f, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0x6f, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xfe, 0x2e, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0x50, 0x5f, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xa0, 0x0, + 0xbf, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xe1, 0x0, 0x1, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf5, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x3f, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x30, 0x0, + 0xd, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xfd, 0x0, 0x9, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf9, + 0x4, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xf4, + + /* U+0079 "y" */ + 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0x50, 0x9f, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xf0, 0x3, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xfa, 0x0, 0xd, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0x40, 0x0, 0x7f, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xe0, 0x0, 0x1, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xf8, 0x0, 0x0, 0xb, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x5f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x90, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xa0, 0x0, + 0x0, 0x1f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0x10, 0x0, 0x6, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf6, + 0x0, 0x0, 0xcf, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xc0, 0x0, 0x2f, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0x10, 0x8, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xf7, 0x0, 0xdf, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xc0, 0x3f, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x17, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf6, 0xcf, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xbf, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x5f, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xee, 0xff, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x57, 0x75, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+007A "z" */ + 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x99, 0x99, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x9d, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xdb, 0xcc, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdc, 0xf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0xf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + + /* U+007B "{" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x36, 0x77, 0x40, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xfb, 0x76, 0x30, 0x0, 0x0, + 0x1f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xef, 0xff, 0x50, 0x0, 0x0, 0x1, 0x37, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfe, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfd, 0x10, + 0x0, 0x0, 0x0, 0x1, 0x5e, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xa7, 0x63, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x4, 0x67, 0x74, + + /* U+007C "|" */ + 0x6f, 0xff, 0x66, 0xff, 0xf6, 0x6f, 0xff, 0x66, + 0xff, 0xf6, 0x6f, 0xff, 0x66, 0xff, 0xf6, 0x6f, + 0xff, 0x66, 0xff, 0xf6, 0x6f, 0xff, 0x66, 0xff, + 0xf6, 0x6f, 0xff, 0x66, 0xff, 0xf6, 0x6f, 0xff, + 0x66, 0xff, 0xf6, 0x6f, 0xff, 0x66, 0xff, 0xf6, + 0x6f, 0xff, 0x66, 0xff, 0xf6, 0x6f, 0xff, 0x66, + 0xff, 0xf6, 0x6f, 0xff, 0x66, 0xff, 0xf6, 0x6f, + 0xff, 0x66, 0xff, 0xf6, 0x6f, 0xff, 0x66, 0xff, + 0xf6, 0x6f, 0xff, 0x66, 0xff, 0xf6, 0x6f, 0xff, + 0x66, 0xff, 0xf6, 0x6f, 0xff, 0x66, 0xff, 0xf6, + 0x6f, 0xff, 0x66, 0xff, 0xf6, 0x6f, 0xff, 0x66, + 0xff, 0xf6, 0x6f, 0xff, 0x66, 0xff, 0xf6, 0x6f, + 0xff, 0x66, 0xff, 0xf6, 0x6f, 0xff, 0x66, 0xff, + 0xf6, 0x6f, 0xff, 0x66, 0xff, 0xf6, 0x6f, 0xff, + 0x66, 0xff, 0xf6, 0x6f, 0xff, 0x66, 0xff, 0xf6, + + /* U+007D "}" */ + 0x67, 0x76, 0x30, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xe4, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x56, 0x8c, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xd6, 0x30, 0x0, 0x0, 0x0, + 0x3, 0xef, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x1, 0x9f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x1a, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xfb, 0x41, 0x0, 0x0, 0x0, 0xb, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xc0, + 0x0, 0x0, 0x5, 0x68, 0xdf, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xfd, 0x50, 0x0, 0x0, 0x0, + 0x6, 0x77, 0x52, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+007E "~" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xad, + 0xff, 0xd9, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x81, 0x4, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xa4, 0x0, 0x0, 0x0, 0x0, 0xa, 0xf1, 0x6f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0x20, + 0x0, 0x6, 0xef, 0xf1, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0xbc, 0xff, 0xff, + 0xf1, 0xef, 0xff, 0xfc, 0xbc, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xef, 0xe6, + 0x0, 0x0, 0x5, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xa0, 0xec, 0x10, 0x0, 0x0, 0x0, + 0x2, 0x8e, 0xff, 0xff, 0xff, 0xff, 0xe7, 0x0, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x49, + 0xcf, 0xfe, 0xb6, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+00A0 " " */ + + /* U+00A3 "£" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x46, 0x77, + 0x53, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6c, 0xff, 0xff, 0xff, 0xfe, 0x81, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xfe, 0x84, 0x33, 0x7d, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0x10, 0x0, 0x1, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf5, 0x0, 0x0, 0x3f, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xfe, 0x60, 0x0, + 0x4, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0x20, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x8, 0xaa, + 0xaa, 0xff, 0xff, 0xda, 0xaa, 0xaa, 0xa4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xcf, 0xff, 0x68, 0xaa, + 0x97, 0x30, 0x0, 0x0, 0x0, 0x0, 0x1, 0x10, + 0x3, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x74, 0x0, 0x0, 0x39, 0xf6, 0x1, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdc, + 0xef, 0xff, 0xb0, 0xc, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x10, 0x6f, 0xff, 0xd8, 0x41, 0x0, 0x36, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, 0xfd, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x5, 0xae, 0xff, + 0xff, 0xff, 0xa3, 0x0, 0x4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0x67, 0x63, 0x0, + 0x0, + + /* U+00A4 "¤" */ + 0x0, 0x6, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0x50, 0x0, 0x7, 0xfd, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0x40, 0x6, 0xff, 0xfd, 0x10, 0x17, 0xcf, 0xff, + 0xfb, 0x60, 0x3, 0xef, 0xff, 0x40, 0xcf, 0xff, + 0xfd, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xef, + 0xff, 0xf9, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0xef, 0xff, 0xfe, + 0x72, 0x1, 0x39, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xfc, 0x10, 0x0, 0x0, 0x3, + 0xef, 0xff, 0xe1, 0x0, 0x0, 0xa, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x70, + 0x0, 0x0, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xfd, 0x0, 0x0, 0x3f, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xf0, 0x0, 0x6, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x20, 0x0, 0x6f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xf3, 0x0, 0x5, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x20, 0x0, + 0x3f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf0, 0x0, 0x0, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfc, 0x0, + 0x0, 0xa, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0x60, 0x0, 0x0, 0x2f, 0xff, + 0xfd, 0x10, 0x0, 0x0, 0x4, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0x83, 0x12, + 0x4a, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x1, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0x0, 0x1, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0xcf, + 0xff, 0xfc, 0x6e, 0xff, 0xff, 0xff, 0xff, 0xd6, + 0xef, 0xff, 0xf9, 0x5, 0xff, 0xfc, 0x0, 0x6, + 0xbe, 0xff, 0xda, 0x50, 0x2, 0xef, 0xff, 0x30, + 0x6, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xef, 0x30, 0x0, 0x5, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x40, + 0x0, + + /* U+00A5 "¥" */ + 0xaf, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf7, 0x2f, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xe0, 0x8, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0x50, 0x0, 0xef, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, + 0x0, 0x6f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xf3, 0x0, 0x0, 0xd, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0x40, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xc0, 0x0, 0x0, 0x2f, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf6, + 0x0, 0x0, 0xbf, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xfe, 0x0, 0x3, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0x70, 0xc, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xe0, 0x4f, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xf7, 0xcf, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x4, 0xaa, + 0xaa, 0xaa, 0xab, 0xff, 0xff, 0xff, 0xff, 0xaa, + 0xaa, 0xaa, 0xaa, 0x20, 0x6, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x30, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, + 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x77, 0x77, 0x77, 0x77, 0x79, 0xff, 0xff, + 0x87, 0x77, 0x77, 0x77, 0x77, 0x10, 0x6, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x30, 0x6, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x30, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00A6 "¦" */ + 0x4a, 0xaa, 0x46, 0xff, 0xf6, 0x6f, 0xff, 0x66, + 0xff, 0xf6, 0x6f, 0xff, 0x66, 0xff, 0xf6, 0x6f, + 0xff, 0x66, 0xff, 0xf6, 0x6f, 0xff, 0x66, 0xff, + 0xf6, 0x6f, 0xff, 0x66, 0xff, 0xf6, 0x6f, 0xff, + 0x66, 0xff, 0xf6, 0x6f, 0xff, 0x66, 0xff, 0xf6, + 0x6f, 0xff, 0x66, 0xff, 0xf6, 0x6f, 0xff, 0x66, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4a, 0xaa, + 0x46, 0xff, 0xf6, 0x6f, 0xff, 0x66, 0xff, 0xf6, + 0x6f, 0xff, 0x66, 0xff, 0xf6, 0x6f, 0xff, 0x66, + 0xff, 0xf6, 0x6f, 0xff, 0x66, 0xff, 0xf6, 0x6f, + 0xff, 0x66, 0xff, 0xf6, 0x6f, 0xff, 0x66, 0xff, + 0xf6, 0x6f, 0xff, 0x66, 0xff, 0xf6, 0x6f, 0xff, + 0x66, 0xff, 0xf6, 0x6f, 0xff, 0x66, 0xff, 0xf6, + + /* U+00A7 "§" */ + 0x0, 0x0, 0x0, 0x0, 0x15, 0x67, 0x65, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5d, + 0xff, 0xff, 0xff, 0xfe, 0x81, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x40, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xf9, 0x43, 0x37, 0xdf, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0xf, 0xff, 0xfd, + 0x20, 0x0, 0x0, 0xb, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x5f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xe0, 0x0, 0x0, 0x8f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf3, 0x0, + 0x0, 0x8f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf6, 0x0, 0x0, 0x6f, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x6, 0x53, 0x20, 0x0, + 0x0, 0x2f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xfd, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4c, 0xff, 0xff, 0xff, 0xd3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1c, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x91, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xef, 0xff, 0xc3, 0x9f, 0xff, 0xff, 0xfe, + 0x50, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfb, 0x0, + 0x5, 0xef, 0xff, 0xff, 0xfb, 0x10, 0x0, 0x0, + 0x5f, 0xff, 0xd0, 0x0, 0x0, 0x1a, 0xff, 0xff, + 0xff, 0xe4, 0x0, 0x0, 0xbf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x4e, 0xff, 0xff, 0xff, 0x70, 0x0, + 0xdf, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xf8, 0x0, 0xef, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xef, 0xff, 0xff, 0x60, + 0xcf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2d, 0xff, 0xff, 0xe0, 0x9f, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xf4, + 0x3f, 0xff, 0xfc, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xf8, 0xa, 0xff, 0xff, 0xd3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf9, + 0x0, 0xcf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf8, 0x0, 0x1c, 0xff, 0xff, + 0xfd, 0x30, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf6, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf9, 0x10, 0x0, + 0x0, 0x1f, 0xff, 0xf1, 0x0, 0x0, 0x5, 0xef, + 0xff, 0xff, 0xe5, 0x0, 0x0, 0xbf, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x1a, 0xff, 0xff, 0xff, 0xb1, + 0x2c, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4e, 0xff, 0xff, 0xfe, 0xff, 0xfd, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xdf, 0xff, 0xff, 0xe2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4e, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xef, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfa, 0x0, + 0x2, 0x8a, 0xcf, 0x20, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xfd, 0x0, 0x3, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xfe, 0x0, + 0x0, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xfd, 0x0, 0x0, 0xaf, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfa, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x2, + 0xdf, 0xff, 0xf4, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xfd, 0x75, 0x46, 0xaf, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xb1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3a, 0xff, 0xff, 0xff, 0xff, + 0xc5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0x67, 0x76, 0x41, 0x0, 0x0, 0x0, 0x0, + + /* U+00A8 "¨" */ + 0x1, 0x11, 0x10, 0x0, 0x0, 0x11, 0x11, 0x8, + 0xff, 0xff, 0x10, 0x0, 0x6f, 0xff, 0xf3, 0x8f, + 0xff, 0xf1, 0x0, 0x6, 0xff, 0xff, 0x38, 0xff, + 0xff, 0x10, 0x0, 0x6f, 0xff, 0xf3, 0x8f, 0xff, + 0xf1, 0x0, 0x6, 0xff, 0xff, 0x38, 0xff, 0xff, + 0x10, 0x0, 0x6f, 0xff, 0xf3, + + /* U+00A9 "©" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x6a, 0xdf, 0xff, 0xff, 0xda, 0x61, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3b, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xb2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xfc, 0x84, 0x20, 0x1, 0x25, 0x9e, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xa2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xcf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5e, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1c, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf4, 0x0, 0x0, 0x2, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x4, 0x8c, 0xef, + 0xfd, 0x94, 0x0, 0x0, 0x0, 0xc, 0xff, 0xe1, + 0x0, 0x0, 0xaf, 0xfd, 0x0, 0x0, 0x0, 0x2c, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0x10, 0x0, 0x0, + 0x2f, 0xff, 0x90, 0x0, 0x2f, 0xff, 0x30, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xed, 0xef, 0xff, 0xfe, + 0x20, 0x0, 0x0, 0x6f, 0xff, 0x10, 0xa, 0xff, + 0xa0, 0x0, 0x0, 0x2f, 0xff, 0xf8, 0x20, 0x0, + 0x18, 0xff, 0xfd, 0x0, 0x0, 0x0, 0xef, 0xf8, + 0x0, 0xff, 0xf3, 0x0, 0x0, 0xc, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xf7, 0x0, 0x0, + 0x6, 0xff, 0xe0, 0x5f, 0xfd, 0x0, 0x0, 0x4, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xc0, 0x0, 0x0, 0x1f, 0xff, 0x38, 0xff, 0x80, + 0x0, 0x0, 0xaf, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0x30, 0x0, 0x0, 0x0, 0xbf, 0xf7, + 0xbf, 0xf5, 0x0, 0x0, 0xe, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0x9e, 0xff, 0x20, 0x0, 0x1, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xfb, 0xff, 0xf1, 0x0, + 0x0, 0x2f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xcf, + 0xff, 0x0, 0x0, 0x2, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xfd, 0xff, 0xf1, 0x0, 0x0, 0x2f, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xce, 0xff, 0x20, 0x0, + 0x0, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfb, 0xcf, + 0xf5, 0x0, 0x0, 0xd, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x64, 0x0, 0x0, 0x0, 0x7, + 0xff, 0x99, 0xff, 0x90, 0x0, 0x0, 0x9f, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x20, + 0x0, 0x0, 0xbf, 0xf6, 0x5f, 0xfd, 0x0, 0x0, + 0x3, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xe0, 0x0, 0x0, 0xf, 0xff, 0x20, 0xff, + 0xf3, 0x0, 0x0, 0xb, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf7, 0x0, 0x0, 0x6, 0xff, + 0xd0, 0xa, 0xff, 0xb0, 0x0, 0x0, 0x1f, 0xff, + 0xf9, 0x20, 0x0, 0x5c, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0xdf, 0xf7, 0x0, 0x3f, 0xff, 0x40, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfd, + 0x10, 0x0, 0x0, 0x6f, 0xff, 0x10, 0x0, 0xbf, + 0xfe, 0x10, 0x0, 0x0, 0x3c, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x10, 0x0, 0x0, 0x2f, 0xff, 0x80, + 0x0, 0x2, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x4, + 0x9d, 0xef, 0xec, 0x82, 0x0, 0x0, 0x0, 0x1d, + 0xff, 0xd0, 0x0, 0x0, 0x6, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1c, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xfc, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2d, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xfe, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xb4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xcf, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xfe, 0x96, 0x32, 0x12, 0x36, + 0xae, 0xff, 0xff, 0xe4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x91, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3a, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x59, 0xce, 0xff, 0xfe, 0xb8, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00AA "ª" */ + 0x0, 0x0, 0x17, 0xce, 0xfd, 0x93, 0x0, 0xaf, + 0xfd, 0x0, 0x0, 0x4e, 0xff, 0xff, 0xff, 0xf8, + 0xe, 0xff, 0x90, 0x0, 0x4f, 0xff, 0xfe, 0xcd, + 0xff, 0xf9, 0xff, 0xf4, 0x0, 0x1e, 0xff, 0xf7, + 0x0, 0x3, 0xef, 0xff, 0xff, 0x0, 0x7, 0xff, + 0xf9, 0x0, 0x0, 0x2, 0xff, 0xff, 0xc0, 0x0, + 0xcf, 0xff, 0x10, 0x0, 0x0, 0xa, 0xff, 0xf9, + 0x0, 0xf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0x50, 0x2, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xf2, 0x0, 0x3f, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x0, 0x3, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xf0, 0x0, 0x2f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x20, + 0x0, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xf5, 0x0, 0xc, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x90, 0x0, 0x6f, 0xff, 0x80, 0x0, + 0x0, 0x5f, 0xff, 0xfd, 0x0, 0x0, 0xdf, 0xff, + 0x60, 0x0, 0x4f, 0xff, 0xff, 0xf1, 0x0, 0x4, + 0xff, 0xff, 0xdb, 0xdf, 0xff, 0xaf, 0xff, 0x60, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, 0x90, 0xcf, + 0xfb, 0x0, 0x0, 0x1, 0x8d, 0xff, 0xda, 0x40, + 0x3, 0x77, 0x60, + + /* U+00AB "«" */ + 0x0, 0x0, 0x0, 0x1, 0xaa, 0xa6, 0x0, 0x0, + 0x6, 0xaa, 0xa1, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf2, 0x0, 0x0, 0x3f, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0x80, 0x0, 0x0, 0xdf, 0xff, + 0x10, 0x0, 0x0, 0x1, 0xef, 0xfe, 0x10, 0x0, + 0x8, 0xff, 0xf7, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xf6, 0x0, 0x0, 0x3f, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x0, 0xdf, 0xff, + 0x50, 0x0, 0x0, 0x2, 0xff, 0xff, 0x40, 0x0, + 0x9, 0xff, 0xfc, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xfb, 0x0, 0x0, 0x4f, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xf3, 0x0, 0x0, 0xdf, 0xff, + 0xa0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x90, 0x0, + 0x9, 0xff, 0xff, 0x10, 0x0, 0x0, 0xc, 0xff, + 0xff, 0x10, 0x0, 0x4f, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xf8, 0x0, 0x0, 0xdf, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfd, 0x0, + 0x0, 0x8f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0x60, 0x0, 0xc, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xe0, 0x0, 0x2, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xf8, 0x0, 0x0, 0x7f, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0x20, 0x0, 0xc, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xa0, + 0x0, 0x2, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xf3, 0x0, 0x0, 0x7f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xfc, 0x0, 0x0, + 0xc, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0x50, 0x0, 0x2, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xd0, 0x0, 0x0, 0x6f, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf7, + 0x0, 0x0, 0xc, 0xff, 0xe1, + + /* U+00AC "¬" */ + 0x3, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x13, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf6, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x63, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf6, + + /* U+00AD "­" */ + 0x38, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x6, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0x6f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x16, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0x6f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x10, + + /* U+00AE "®" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x6a, 0xdf, 0xff, 0xff, 0xda, 0x61, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3b, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xb2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xfc, 0x84, 0x20, 0x1, 0x25, 0x9e, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xa2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xcf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5e, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1c, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xf4, 0x0, 0x0, 0x2, + 0xff, 0xfa, 0x0, 0x7, 0xbb, 0xbb, 0xbb, 0xbb, + 0xa8, 0x51, 0x0, 0x0, 0x0, 0xc, 0xff, 0xe1, + 0x0, 0x0, 0xaf, 0xfd, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0x90, 0x0, 0x2f, 0xff, 0x30, 0x0, + 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x10, 0xa, 0xff, + 0xa0, 0x0, 0x0, 0xaf, 0xf8, 0x0, 0x0, 0x3, + 0x7e, 0xff, 0xf1, 0x0, 0x0, 0x0, 0xef, 0xf8, + 0x0, 0xff, 0xf3, 0x0, 0x0, 0xa, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x70, 0x0, 0x0, + 0x6, 0xff, 0xe0, 0x5f, 0xfd, 0x0, 0x0, 0x0, + 0xaf, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xf9, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x38, 0xff, 0x80, + 0x0, 0x0, 0xa, 0xff, 0x80, 0x0, 0x0, 0x0, + 0xd, 0xff, 0x90, 0x0, 0x0, 0x0, 0xbf, 0xf7, + 0xbf, 0xf5, 0x0, 0x0, 0x0, 0xaf, 0xf8, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x8, 0xff, 0x9e, 0xff, 0x20, 0x0, 0x0, 0xa, + 0xff, 0x80, 0x0, 0x0, 0x5, 0xef, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xfb, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0xaf, 0xfe, 0xcc, 0xcc, 0xdf, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x4, 0xff, 0xcf, + 0xff, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xfd, 0xff, 0xf1, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xa3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xce, 0xff, 0x20, 0x0, + 0x0, 0xa, 0xff, 0x80, 0x2, 0x7f, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xfb, 0xcf, + 0xf5, 0x0, 0x0, 0x0, 0xaf, 0xf8, 0x0, 0x0, + 0x3f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0x99, 0xff, 0x90, 0x0, 0x0, 0xa, 0xff, + 0x80, 0x0, 0x0, 0x6f, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xf6, 0x5f, 0xfd, 0x0, 0x0, + 0x0, 0xaf, 0xf8, 0x0, 0x0, 0x0, 0xcf, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0x20, 0xff, + 0xf3, 0x0, 0x0, 0xa, 0xff, 0x80, 0x0, 0x0, + 0x3, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xd0, 0xa, 0xff, 0xb0, 0x0, 0x0, 0xaf, 0xf8, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0xdf, 0xf7, 0x0, 0x3f, 0xff, 0x40, 0x0, + 0xa, 0xff, 0x80, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xb0, 0x0, 0x0, 0x6f, 0xff, 0x10, 0x0, 0xbf, + 0xfe, 0x10, 0x0, 0xaf, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0x50, 0x0, 0x2f, 0xff, 0x80, + 0x0, 0x2, 0xff, 0xfc, 0x0, 0x6, 0x99, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x99, 0x97, 0x0, 0x1d, + 0xff, 0xd0, 0x0, 0x0, 0x6, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1c, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xfc, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2d, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xfe, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xb4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xcf, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xfe, 0x96, 0x32, 0x12, 0x36, + 0xae, 0xff, 0xff, 0xe4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x91, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3a, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x59, 0xce, 0xff, 0xfe, 0xb8, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00B0 "°" */ + 0x0, 0x0, 0x38, 0xaa, 0x83, 0x0, 0x0, 0x0, + 0x1a, 0xff, 0xff, 0xff, 0xa1, 0x0, 0x1, 0xdf, + 0xff, 0xff, 0xff, 0xfd, 0x10, 0xb, 0xff, 0xd4, + 0x0, 0x5d, 0xff, 0xb0, 0x3f, 0xfd, 0x0, 0x0, + 0x1, 0xdf, 0xf3, 0x9f, 0xf4, 0x0, 0x0, 0x0, + 0x4f, 0xf8, 0xbf, 0xf0, 0x0, 0x0, 0x0, 0xf, + 0xfb, 0xbf, 0xe0, 0x0, 0x0, 0x0, 0xe, 0xfb, + 0xaf, 0xf2, 0x0, 0x0, 0x0, 0x2f, 0xf9, 0x5f, + 0xfa, 0x0, 0x0, 0x0, 0xaf, 0xf5, 0xd, 0xff, + 0x90, 0x0, 0x9, 0xff, 0xd0, 0x3, 0xff, 0xff, + 0xcc, 0xff, 0xff, 0x30, 0x0, 0x3e, 0xff, 0xff, + 0xff, 0xe4, 0x0, 0x0, 0x1, 0x8d, 0xff, 0xd8, + 0x10, 0x0, + + /* U+00B1 "±" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x63, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x63, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x2, + 0x22, 0x22, 0x22, 0x22, 0x8f, 0xff, 0xb2, 0x22, + 0x22, 0x22, 0x22, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x11, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x22, 0x22, + 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x63, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x3f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x60, + + /* U+00B2 "²" */ + 0x0, 0x0, 0x39, 0xdf, 0xff, 0xda, 0x60, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x20, + 0x0, 0xaf, 0xff, 0xff, 0xef, 0xff, 0xff, 0xe1, + 0x4, 0xff, 0xfe, 0x40, 0x0, 0x4e, 0xff, 0xf7, + 0xb, 0xff, 0xf3, 0x0, 0x0, 0x5, 0xff, 0xfa, + 0x3, 0x57, 0x70, 0x0, 0x0, 0x3, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xef, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x1c, 0xff, 0xfe, 0x40, 0x0, + 0x0, 0x0, 0x5, 0xef, 0xff, 0xc2, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xfe, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + + /* U+00B3 "³" */ + 0x0, 0x0, 0x5b, 0xdf, 0xfe, 0xc9, 0x40, 0x0, + 0x0, 0x1d, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0xdf, 0xff, 0xfc, 0xce, 0xff, 0xff, 0x80, + 0x7, 0xff, 0xf9, 0x0, 0x0, 0x5f, 0xff, 0xd0, + 0x3, 0x68, 0x90, 0x0, 0x0, 0xf, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x8, 0xbe, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xfe, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xfc, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x7f, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfb, + 0x6, 0x89, 0x50, 0x0, 0x0, 0x2, 0xff, 0xfb, + 0xf, 0xff, 0xe0, 0x0, 0x0, 0x8, 0xff, 0xf9, + 0x8, 0xff, 0xfc, 0x20, 0x1, 0x9f, 0xff, 0xf3, + 0x1, 0xef, 0xff, 0xff, 0xef, 0xff, 0xff, 0x90, + 0x0, 0x2c, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x5a, 0xdf, 0xfe, 0xc8, 0x20, 0x0, + + /* U+00B5 "µ" */ + 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf5, 0x9f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf5, 0x9f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf5, 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf5, 0x9f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf5, 0x9f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf5, 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf5, 0x9f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf5, + 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf5, 0x9f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf5, 0x9f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf5, 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf5, 0x9f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf5, 0x9f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf5, 0x9f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf5, 0x9f, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf5, + 0x9f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf5, 0x9f, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf5, 0x9f, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xf5, 0x9f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xf5, 0x9f, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf5, 0x9f, + 0xff, 0xff, 0xf9, 0x10, 0x0, 0x3, 0xcf, 0xff, + 0xff, 0xf5, 0x9f, 0xff, 0xff, 0xff, 0xfb, 0x99, + 0xdf, 0xff, 0xff, 0xff, 0xf5, 0x9f, 0xff, 0xde, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd9, 0xff, 0xf5, + 0x9f, 0xff, 0xc2, 0xef, 0xff, 0xff, 0xff, 0xfd, + 0x29, 0xff, 0xf5, 0x9f, 0xff, 0xc0, 0x1a, 0xff, + 0xff, 0xff, 0xa1, 0x9, 0xff, 0xf5, 0x9f, 0xff, + 0xc0, 0x0, 0x15, 0x76, 0x51, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+00B6 "¶" */ + 0x0, 0x0, 0x0, 0x4, 0x8c, 0xde, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x6, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd4, + 0x44, 0x44, 0xdf, 0xff, 0x94, 0x44, 0x1, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0xcf, 0xff, 0x60, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0xcf, 0xff, + 0x60, 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0xcf, 0xff, 0x60, 0x0, + 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0xcf, 0xff, 0x60, 0x0, 0xf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0xcf, 0xff, 0x60, 0x0, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0xcf, 0xff, + 0x60, 0x0, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0xcf, 0xff, 0x60, 0x0, + 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0xcf, 0xff, 0x60, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0xcf, 0xff, 0x60, 0x0, 0x5, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0xcf, 0xff, + 0x60, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0xcf, 0xff, 0x60, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0xcf, 0xff, 0x60, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0xcf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x4e, 0xff, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0xcf, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x7c, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0xcf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x6f, 0xff, 0xc0, + 0x0, 0x0, 0xcf, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, + 0xcf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, 0xcf, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xc0, 0x0, 0x0, 0xcf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, + 0x0, 0x0, 0xcf, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, + 0xcf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, 0xcf, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xc0, 0x0, 0x0, 0xcf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, + 0x0, 0x0, 0xcf, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, + 0xcf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, 0xcf, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xc0, 0x0, 0x0, 0xcf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, + 0x0, 0x0, 0xcf, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, + 0xcf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, 0xcf, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xc0, 0x0, 0x0, 0xcf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, + 0x0, 0x0, 0xcf, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, + 0xcf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, 0xcf, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xc0, 0x0, 0x0, 0xcf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, + 0x0, 0x0, 0xcf, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, + 0xcf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, 0xcf, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xc0, 0x0, 0x0, 0xcf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, + 0x0, 0x0, 0xcf, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, + 0xcf, 0xff, 0x60, 0x0, + + /* U+00B7 "·" */ + 0x1, 0x11, 0x10, 0x8f, 0xff, 0xf8, 0x8f, 0xff, + 0xf8, 0x8f, 0xff, 0xf8, 0x8f, 0xff, 0xf8, 0x8f, + 0xff, 0xf8, + + /* U+00BB "»" */ + 0x3a, 0xaa, 0x40, 0x0, 0x0, 0x8a, 0xa9, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xe1, 0x0, 0x0, + 0x5f, 0xff, 0x70, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xfa, 0x0, 0x0, 0xb, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x50, 0x0, 0x3, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xe1, + 0x0, 0x0, 0xaf, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xfb, 0x0, 0x0, 0x1f, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x60, 0x0, + 0x8, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xf1, 0x0, 0x0, 0xef, 0xff, 0x90, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xfb, 0x0, 0x0, 0x6f, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0x60, 0x0, 0xc, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xf2, 0x0, 0x4, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfa, 0x0, + 0x0, 0xcf, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xf5, 0x0, 0x1, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xa0, 0x0, 0x9, 0xff, + 0xff, 0x30, 0x0, 0x0, 0xa, 0xff, 0xfe, 0x10, + 0x0, 0x3f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf4, 0x0, 0x0, 0xbf, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x90, 0x0, 0x4, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x5, 0xff, 0xfd, 0x0, + 0x0, 0xd, 0xff, 0xf6, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf4, 0x0, 0x0, 0x6f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x90, 0x0, 0x0, 0xef, + 0xff, 0x10, 0x0, 0x0, 0x1, 0xff, 0xfd, 0x0, + 0x0, 0x8, 0xff, 0xf5, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf3, 0x0, 0x0, 0x2f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0x80, 0x0, 0x0, 0xaf, + 0xfe, 0x10, 0x0, 0x0, 0x0, + + /* U+00BD "½" */ + 0x0, 0x0, 0x0, 0x5d, 0xd8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbd, + 0xdc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x6, 0xef, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xaf, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xfe, 0x50, + 0xef, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xb5, 0x0, 0xe, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xfa, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x28, 0xce, 0xfe, 0xda, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfe, + 0x10, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xc1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0x50, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x90, 0x0, + 0x0, 0x2f, 0xff, 0xf6, 0x10, 0x16, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xd0, 0x0, 0x0, 0x9, 0xff, 0xf5, 0x0, + 0x0, 0x6, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x7a, 0xbc, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xcf, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xef, 0xff, 0xd2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xfe, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xfd, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x1e, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0xb, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x0, 0x2, 0x88, + 0x84, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+0384 "΄" */ + 0x0, 0x8, 0xff, 0xff, 0xe1, 0x0, 0x1f, 0xff, + 0xff, 0x40, 0x0, 0x7f, 0xff, 0xf8, 0x0, 0x0, + 0xef, 0xff, 0xb0, 0x0, 0x6, 0xff, 0xfe, 0x10, + 0x0, 0xd, 0xff, 0xf3, 0x0, 0x0, 0x5f, 0xff, + 0x70, 0x0, 0x0, + + /* U+0386 "Ά" */ + 0x0, 0x0, 0xa, 0xff, 0xff, 0xd1, 0x0, 0x7f, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf3, 0x0, + 0xd, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf6, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xf9, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xfd, 0x0, 0x0, 0xf, 0xff, 0xfa, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x20, 0x0, 0x6, 0xff, 0xfc, + 0x5f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x40, 0x0, 0x0, 0xcf, + 0xff, 0x80, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf3, 0xa, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xfe, 0x0, 0x4f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x90, 0x0, 0xef, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf4, 0x0, + 0x8, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, + 0x0, 0x0, 0x2f, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0x80, 0x0, 0x0, 0xcf, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xf2, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xd0, 0x0, 0x0, 0xe, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0x30, 0x0, 0x5, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfa, 0x0, + 0x0, 0xbf, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xf1, 0x0, 0x1f, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0x70, 0x7, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xfd, 0x0, 0xdf, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xf4, + + /* U+0388 "Έ" */ + 0x0, 0x2, 0xff, 0xff, 0xf7, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0xa, 0xff, 0xff, + 0xa0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x1f, 0xff, 0xfd, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x8f, 0xff, 0xf2, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, + 0x1, 0xff, 0xff, 0x50, 0x0, 0x0, 0x3f, 0xff, + 0xfa, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, + 0x44, 0x44, 0x44, 0x30, 0x7, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xfa, 0x44, 0x44, 0x44, + 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x41, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xfa, 0x44, 0x44, 0x44, + 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x42, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + + /* U+0389 "Ή" */ + 0x0, 0x2, 0xff, 0xff, 0xf7, 0x3, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xfd, 0x0, 0x9, 0xff, 0xff, + 0xb0, 0x3, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfd, + 0x0, 0x1f, 0xff, 0xfd, 0x10, 0x3, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xfd, 0x0, 0x8f, 0xff, 0xf3, + 0x0, 0x3, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfd, + 0x1, 0xff, 0xff, 0x60, 0x0, 0x3, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xfd, 0x7, 0xff, 0xf9, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfd, + 0xd, 0xff, 0xc0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xa5, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x5e, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfd, + + /* U+038A "Ί" */ + 0x0, 0x2, 0xff, 0xff, 0xf7, 0x3, 0xff, 0xff, + 0x80, 0x0, 0x9f, 0xff, 0xfb, 0x0, 0x3f, 0xff, + 0xf8, 0x0, 0x1f, 0xff, 0xfd, 0x10, 0x3, 0xff, + 0xff, 0x80, 0x8, 0xff, 0xff, 0x30, 0x0, 0x3f, + 0xff, 0xf8, 0x1, 0xff, 0xff, 0x60, 0x0, 0x3, + 0xff, 0xff, 0x80, 0x7f, 0xff, 0x90, 0x0, 0x0, + 0x3f, 0xff, 0xf8, 0xd, 0xff, 0xc0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf8, + + /* U+038C "Ό" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x24, 0x67, 0x77, 0x53, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x3, 0x9e, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x71, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xa0, 0x0, 0x4, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfd, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf2, 0x0, 0x1d, 0xff, 0xff, + 0xff, 0xff, 0xdb, 0xac, 0xdf, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x50, + 0x1, 0xef, 0xff, 0xff, 0xf9, 0x40, 0x0, 0x0, + 0x1, 0x6c, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x7, 0xff, 0xf9, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5e, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0xd, 0xff, 0xc0, 0x0, + 0x9f, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xdf, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1d, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0x70, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf1, + 0x0, 0x0, 0xa, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf3, 0x0, 0x0, 0xc, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf5, + 0x0, 0x0, 0xd, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf5, 0x0, 0x0, 0xd, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf5, + 0x0, 0x0, 0xc, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xf5, 0x0, 0x0, 0xb, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf3, + 0x0, 0x0, 0x9, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xf2, 0x0, 0x0, 0x6, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xf9, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5e, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xff, + 0xe8, 0x30, 0x0, 0x0, 0x1, 0x5c, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1c, 0xff, 0xff, 0xff, 0xfe, 0xcb, 0xab, + 0xdf, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0x9e, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x71, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x14, 0x67, 0x77, + 0x53, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+038E "Ύ" */ + 0x0, 0x2, 0xff, 0xff, 0xf7, 0x0, 0x6f, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xb0, 0x0, + 0xa, 0xff, 0xff, 0xa0, 0x0, 0xb, 0xff, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0x10, 0x0, 0x1f, + 0xff, 0xfd, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x8f, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xb0, 0x0, 0x1, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xfe, 0x10, 0x0, 0x7, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xf5, + 0x0, 0x0, 0xd, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0x20, 0x0, 0x8, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xb0, 0x0, 0x3f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf4, + 0x0, 0xcf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xfd, 0x6, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0x8e, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+038F "Ώ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x25, 0x67, 0x76, 0x52, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x4a, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xb5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xa0, 0x0, 0x4, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xd0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xf2, 0x0, 0xb, 0xff, 0xff, 0xff, 0xfe, + 0xca, 0xac, 0xef, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xf5, 0x0, 0xc, 0xff, + 0xff, 0xff, 0x94, 0x0, 0x0, 0x0, 0x4a, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x7, 0xff, 0xf9, + 0x0, 0x9, 0xff, 0xff, 0xfd, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xef, 0xff, 0xff, 0x70, 0x0, + 0x0, 0xdf, 0xfc, 0x0, 0x4, 0xff, 0xff, 0xfd, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xfc, 0x10, 0x0, 0x0, 0x0, 0x0, 0x1, 0xcf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1c, 0xff, 0xfe, 0x30, 0x0, 0x0, + 0x0, 0x3, 0xef, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x44, 0x44, 0x44, 0x5e, 0xff, + 0xff, 0x91, 0x0, 0x0, 0x2a, 0xff, 0xff, 0xd5, + 0x44, 0x44, 0x44, 0x10, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0xa, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x40, + + /* U+0390 "ΐ" */ + 0x0, 0x0, 0x0, 0x0, 0x3, 0x88, 0x87, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xd0, 0x0, 0x0, 0x5, 0xff, 0xfe, 0x0, + 0xa, 0xff, 0xf3, 0xc, 0xff, 0xf6, 0x5f, 0xff, + 0xe0, 0x1, 0xff, 0xf8, 0x0, 0xcf, 0xff, 0x65, + 0xff, 0xfe, 0x0, 0x8f, 0xfd, 0x0, 0xc, 0xff, + 0xf6, 0x5f, 0xff, 0xe0, 0xe, 0xff, 0x30, 0x0, + 0xcf, 0xff, 0x64, 0xcc, 0xcb, 0x4, 0xcc, 0x70, + 0x0, 0x9, 0xcc, 0xc5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, 0x0, + 0x0, + + /* U+0391 "Α" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xfa, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfb, + 0x4f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x70, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf3, 0x9, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xfe, 0x0, 0x4f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x90, 0x0, 0xef, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf3, 0x0, + 0x8, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfd, + 0x0, 0x0, 0x2f, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0x70, 0x0, 0x0, 0xcf, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xf2, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xfb, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xd0, 0x0, 0x0, 0xe, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0x30, 0x0, 0x5, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfa, 0x0, + 0x0, 0xbf, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xf1, 0x0, 0x1f, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0x70, 0x7, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xfd, 0x0, 0xdf, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xf4, + + /* U+0392 "Β" */ + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0xdb, 0x84, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd6, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc1, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x10, 0x0, + 0x5f, 0xff, 0xf9, 0x44, 0x44, 0x44, 0x45, 0x57, + 0x9c, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x5f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x19, + 0xff, 0xff, 0xf3, 0x0, 0x5f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xf9, 0x0, 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfd, 0x0, + 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xfe, 0x0, 0x5f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0x0, 0x5f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xfd, 0x0, 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfa, 0x0, + 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xf4, 0x0, 0x5f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xef, 0xff, 0xc0, 0x0, 0x5f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x37, 0xcf, 0xff, 0xfe, + 0x10, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xc1, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xb2, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x5f, 0xff, 0xf9, 0x44, 0x44, 0x44, + 0x44, 0x56, 0x7a, 0xef, 0xff, 0xff, 0xf7, 0x0, + 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xbf, 0xff, 0xff, 0x40, 0x5f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xd0, 0x5f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf3, 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf7, + 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfa, 0x5f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xfb, 0x5f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xfa, 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf8, + 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf4, 0x5f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf0, 0x5f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xaf, 0xff, + 0xff, 0x80, 0x5f, 0xff, 0xf9, 0x44, 0x44, 0x44, + 0x44, 0x45, 0x69, 0xcf, 0xff, 0xff, 0xfe, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x30, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x80, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xed, 0xb8, 0x40, 0x0, 0x0, 0x0, + + /* U+0393 "Γ" */ + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x6f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0xff, 0xff, + 0xd4, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, + 0x44, 0x1f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0394 "Δ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xfa, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfb, + 0x5f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x70, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf3, 0xa, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xfe, 0x0, 0x5f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x90, 0x0, 0xef, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf3, 0x0, + 0x9, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xfe, + 0x0, 0x0, 0x3f, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0x80, 0x0, 0x0, 0xdf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xf2, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xc0, 0x0, 0x0, 0xe, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0x30, 0x0, 0x5, + 0xff, 0xff, 0xb4, 0x44, 0x44, 0x44, 0x44, 0x44, + 0x44, 0x44, 0x44, 0x44, 0xcf, 0xff, 0xf9, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf1, 0x0, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x60, 0x7, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x0, 0xdf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, + + /* U+0395 "Ε" */ + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0xf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd0, 0xf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd0, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, + 0xf, 0xff, 0xfc, 0x44, 0x44, 0x44, 0x44, 0x44, + 0x44, 0x44, 0x44, 0x44, 0x44, 0x30, 0xf, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0xf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf7, 0x0, 0xf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf7, 0x0, 0xf, 0xff, 0xfc, 0x44, 0x44, 0x44, + 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x42, 0x0, + 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xfc, 0x44, 0x44, 0x44, + 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x43, + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0xf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0xf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + + /* U+0396 "Ζ" */ + 0x0, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0xf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0xf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x4, 0x44, 0x44, + 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x8f, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfd, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2e, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xc4, 0x44, 0x44, 0x44, + 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x40, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x1f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x1f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf3, 0x1f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf3, + + /* U+0397 "Η" */ + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x1f, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xf1, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0x1f, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xf1, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0x1f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf1, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0x1f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf1, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0x1f, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xf1, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x1f, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf1, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0x1f, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xf1, 0xff, 0xff, 0xd5, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x5c, 0xff, + 0xff, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf1, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x1f, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xf1, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0x1f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf1, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0x1f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf1, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0x1f, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xf1, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x1f, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf1, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0x1f, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xf1, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0x1f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf1, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x1f, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xf1, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0x1f, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xf1, + + /* U+0398 "Θ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x46, + 0x77, 0x76, 0x41, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x8d, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x82, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2b, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xfd, 0xba, 0xcd, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xfa, 0x50, 0x0, + 0x0, 0x0, 0x5b, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xc3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xdf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xfe, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xf7, 0x0, 0x1, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xe0, + 0x0, 0x6f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0x50, 0xb, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xfa, 0x0, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xf0, 0x3f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x26, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf5, + 0x7f, 0xff, 0xf6, 0x0, 0x0, 0x24, 0x44, 0x44, + 0x44, 0x44, 0x44, 0x44, 0x20, 0x0, 0x7, 0xff, + 0xff, 0x79, 0xff, 0xff, 0x40, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x6f, 0xff, 0xf8, 0xaf, 0xff, 0xf4, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x5, 0xff, 0xff, 0x8a, 0xff, 0xff, 0x30, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x5f, 0xff, 0xf8, 0x9f, 0xff, + 0xf4, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x6, 0xff, 0xff, 0x88, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xf7, 0x6f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0x53, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xf2, 0xf, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0x0, 0xbf, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xb0, 0x6, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf6, + 0x0, 0xf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xfe, 0x0, 0x0, 0x8f, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0x80, 0x0, 0x1, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xfb, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3c, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0x94, 0x0, + 0x0, 0x0, 0x4, 0xaf, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xff, 0xcb, 0xab, 0xdf, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xa1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x28, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xd8, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x67, + 0x77, 0x64, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+0399 "Ι" */ + 0x6f, 0xff, 0xf5, 0x6f, 0xff, 0xf5, 0x6f, 0xff, + 0xf5, 0x6f, 0xff, 0xf5, 0x6f, 0xff, 0xf5, 0x6f, + 0xff, 0xf5, 0x6f, 0xff, 0xf5, 0x6f, 0xff, 0xf5, + 0x6f, 0xff, 0xf5, 0x6f, 0xff, 0xf5, 0x6f, 0xff, + 0xf5, 0x6f, 0xff, 0xf5, 0x6f, 0xff, 0xf5, 0x6f, + 0xff, 0xf5, 0x6f, 0xff, 0xf5, 0x6f, 0xff, 0xf5, + 0x6f, 0xff, 0xf5, 0x6f, 0xff, 0xf5, 0x6f, 0xff, + 0xf5, 0x6f, 0xff, 0xf5, 0x6f, 0xff, 0xf5, 0x6f, + 0xff, 0xf5, 0x6f, 0xff, 0xf5, 0x6f, 0xff, 0xf5, + 0x6f, 0xff, 0xf5, 0x6f, 0xff, 0xf5, 0x6f, 0xff, + 0xf5, 0x6f, 0xff, 0xf5, 0x6f, 0xff, 0xf5, 0x6f, + 0xff, 0xf5, 0x6f, 0xff, 0xf5, 0x6f, 0xff, 0xf5, + 0x6f, 0xff, 0xf5, 0x6f, 0xff, 0xf5, 0x6f, 0xff, + 0xf5, 0x6f, 0xff, 0xf5, + + /* U+039A "Κ" */ + 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xe3, 0x5, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xe2, 0x0, 0x5f, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xe2, 0x0, 0x5, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x5f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xd2, 0x0, 0x0, 0x5, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xd1, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xd1, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xc1, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xc1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0x60, 0x0, 0x4f, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf6, 0x0, 0x4f, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0x60, 0x4f, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xf6, 0x4f, 0xff, 0xff, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xff, 0xff, 0x83, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xff, 0x80, 0x8, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0x80, 0x0, 0xc, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x40, 0x0, + 0x5, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xfe, 0x10, 0x0, + 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xfb, 0x0, 0x5, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xf7, 0x0, 0x5f, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0xf3, 0x5, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xd0, + + /* U+039B "Λ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xaf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x3d, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xfe, 0x9, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf9, 0x3, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf3, + 0x0, 0xef, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xe0, 0x0, 0x8f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x80, 0x0, 0x3f, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0x20, 0x0, 0xd, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xfc, 0x0, 0x0, 0x8, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf6, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0xd, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0x20, 0x0, 0x0, 0x3f, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x80, 0x0, 0x0, 0x9f, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf4, 0x0, + 0x6, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfa, + 0x0, 0xc, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0x10, 0x2f, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0x60, 0x8f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xd0, + + /* U+039C "Μ" */ + 0x3f, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xe3, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xfe, 0x3f, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0xe3, 0xff, 0xff, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xfe, 0x3f, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0xe3, + 0xff, 0xff, 0xef, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0xfe, 0x3f, 0xff, 0xf9, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xcf, 0xff, 0xe3, 0xff, 0xff, 0x5e, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xca, 0xff, 0xfe, 0x3f, 0xff, 0xf5, 0x9f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf7, 0xaf, 0xff, 0xe3, 0xff, 0xff, + 0x54, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x1a, 0xff, 0xfe, 0x3f, + 0xff, 0xf5, 0xe, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xb0, 0xaf, 0xff, + 0xe3, 0xff, 0xff, 0x50, 0x9f, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf6, 0xa, + 0xff, 0xfe, 0x3f, 0xff, 0xf5, 0x4, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x10, 0xaf, 0xff, 0xe3, 0xff, 0xff, 0x50, 0xe, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xb0, 0xa, 0xff, 0xfe, 0x3f, 0xff, 0xf5, + 0x0, 0x9f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xf5, 0x0, 0xaf, 0xff, 0xe3, 0xff, + 0xff, 0x50, 0x4, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x0, 0xa, 0xff, 0xfe, + 0x3f, 0xff, 0xf5, 0x0, 0xe, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xa0, 0x0, 0xaf, + 0xff, 0xe3, 0xff, 0xff, 0x50, 0x0, 0x9f, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf5, 0x0, + 0xa, 0xff, 0xfe, 0x3f, 0xff, 0xf5, 0x0, 0x3, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x0, 0x0, 0xaf, 0xff, 0xe3, 0xff, 0xff, 0x50, + 0x0, 0xe, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xa0, 0x0, 0xa, 0xff, 0xfe, 0x3f, 0xff, + 0xf5, 0x0, 0x0, 0x9f, 0xff, 0xb0, 0x0, 0x0, + 0x7, 0xff, 0xf4, 0x0, 0x0, 0xaf, 0xff, 0xe3, + 0xff, 0xff, 0x50, 0x0, 0x3, 0xff, 0xff, 0x0, + 0x0, 0x0, 0xdf, 0xfe, 0x0, 0x0, 0xa, 0xff, + 0xfe, 0x3f, 0xff, 0xf5, 0x0, 0x0, 0xe, 0xff, + 0xf5, 0x0, 0x0, 0x2f, 0xff, 0x90, 0x0, 0x0, + 0xaf, 0xff, 0xe3, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x8f, 0xff, 0xb0, 0x0, 0x8, 0xff, 0xf4, 0x0, + 0x0, 0xa, 0xff, 0xfe, 0x3f, 0xff, 0xf5, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x0, 0x0, 0xdf, 0xfe, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xe3, 0xff, 0xff, + 0x50, 0x0, 0x0, 0xd, 0xff, 0xf5, 0x0, 0x3f, + 0xff, 0x90, 0x0, 0x0, 0xa, 0xff, 0xfe, 0x3f, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xa0, + 0x8, 0xff, 0xf3, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xe3, 0xff, 0xff, 0x50, 0x0, 0x0, 0x3, 0xff, + 0xff, 0x0, 0xdf, 0xfe, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfe, 0x3f, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xf5, 0x3f, 0xff, 0x80, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xe3, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xa8, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xfe, 0x3f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xdf, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xe3, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, + 0x3f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xe3, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xfe, 0x3f, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xe3, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfe, + + /* U+039D "Ν" */ + 0xf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf2, 0xf, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf2, 0xf, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xf2, 0xf, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xf2, 0xf, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xf2, 0xf, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xf2, 0xf, 0xff, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xf2, 0xf, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf2, + 0xf, 0xff, 0xf9, 0xef, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf2, 0xf, + 0xff, 0xf8, 0x4f, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf2, 0xf, 0xff, + 0xf8, 0xa, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xf2, 0xf, 0xff, 0xf8, + 0x1, 0xef, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xf2, 0xf, 0xff, 0xf8, 0x0, + 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xf2, 0xf, 0xff, 0xf8, 0x0, 0xa, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xf2, 0xf, 0xff, 0xf8, 0x0, 0x1, 0xef, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xf2, 0xf, 0xff, 0xf8, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf2, + 0xf, 0xff, 0xf8, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf2, 0xf, + 0xff, 0xf8, 0x0, 0x0, 0x1, 0xef, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf2, 0xf, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x6f, 0xff, 0xf2, 0xf, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x6f, 0xff, 0xf2, 0xf, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xf7, 0x0, 0x0, + 0x6f, 0xff, 0xf2, 0xf, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x6f, + 0xff, 0xf2, 0xf, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xc0, 0x0, 0x6f, 0xff, + 0xf2, 0xf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xf7, 0x0, 0x6f, 0xff, 0xf2, + 0xf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0x20, 0x6f, 0xff, 0xf2, 0xf, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xc0, 0x6f, 0xff, 0xf2, 0xf, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xff, 0xf6, 0x6f, 0xff, 0xf2, 0xf, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0x8f, 0xff, 0xf2, 0xf, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xff, 0xf2, 0xf, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, + 0xff, 0xf2, 0xf, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0xf2, 0xf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xf2, + 0xf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xf2, 0xf, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf2, 0xf, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xf2, 0xf, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xf2, + + /* U+039E "Ξ" */ + 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0xa, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf2, 0xa, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf2, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + 0x3, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, + 0x44, 0x44, 0x44, 0x44, 0x44, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x44, 0x44, 0x44, 0x44, + 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x30, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x14, 0x44, 0x44, 0x44, 0x44, 0x44, + 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x43, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + + /* U+039F "Ο" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x46, + 0x77, 0x76, 0x41, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x8d, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x82, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2b, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xfd, 0xba, 0xcd, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xfa, 0x50, 0x0, + 0x0, 0x0, 0x5b, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xc3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xdf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xfe, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xf7, 0x0, 0x1, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xe0, + 0x0, 0x6f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0x50, 0xb, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xfa, 0x0, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xf0, 0x3f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x26, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf5, + 0x7f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0x79, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xf8, 0xaf, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0x8a, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf8, 0x9f, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x88, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xf7, 0x6f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0x53, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xf2, 0xf, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0x0, 0xbf, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xb0, 0x6, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf6, + 0x0, 0xf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xfe, 0x0, 0x0, 0x8f, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0x80, 0x0, 0x1, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xfb, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3c, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0x94, 0x0, + 0x0, 0x0, 0x4, 0xaf, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xff, 0xcb, 0xab, 0xdf, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xa1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x28, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xd8, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x67, + 0x77, 0x64, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+03A0 "Π" */ + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf1, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x1f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf1, 0xff, 0xff, 0xd4, 0x44, 0x44, 0x44, + 0x44, 0x44, 0x44, 0x44, 0x44, 0x4c, 0xff, 0xff, + 0x1f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf1, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0x1f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf1, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0x1f, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xf1, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x1f, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf1, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0x1f, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xf1, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0x1f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf1, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x1f, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xf1, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0x1f, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xf1, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0x1f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf1, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0x1f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf1, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0x1f, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xf1, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x1f, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf1, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0x1f, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xf1, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0x1f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf1, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x1f, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xf1, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0x1f, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xf1, + + /* U+03A1 "Ρ" */ + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0xca, 0x73, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x60, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x2f, 0xff, 0xfb, 0x44, 0x44, 0x44, + 0x44, 0x45, 0x56, 0x8b, 0xff, 0xff, 0xff, 0x80, + 0x2, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xdf, 0xff, 0xff, 0x20, 0x2f, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xf8, 0x2, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xd0, 0x2f, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0x2, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xf1, 0x2f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x22, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf1, 0x2f, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0x2, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xb0, 0x2f, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xf7, 0x2, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xdf, 0xff, 0xff, 0x10, + 0x2f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x13, 0x6b, 0xff, 0xff, 0xff, 0x70, 0x2, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x2f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc1, 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0xb6, 0x10, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xb5, 0x55, 0x55, 0x55, 0x54, + 0x44, 0x21, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+03A3 "Σ" */ + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf0, 0x6f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x6f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf0, 0x6f, 0xff, 0xff, 0x64, + 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, + 0x40, 0xb, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xdf, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xfe, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x54, 0x44, + 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x6f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, + + /* U+03A4 "Τ" */ + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf7, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x7e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf7, 0x44, 0x44, 0x44, 0x44, 0x44, 0x46, + 0xff, 0xff, 0xb4, 0x44, 0x44, 0x44, 0x44, 0x44, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+03A5 "Υ" */ + 0x8f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0x90, 0xdf, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xd0, 0x3, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xf3, 0x0, 0x8, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xf8, 0x0, 0x0, 0xd, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x1f, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xfe, 0x10, 0x0, 0xb, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf9, 0x0, 0x5, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf3, 0x0, + 0xef, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xc0, + 0x8f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0x8f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+03A6 "Φ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xdd, 0xdd, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x6a, + 0xce, 0xff, 0xff, 0xff, 0xff, 0xec, 0xa6, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe3, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xe9, + 0x52, 0x16, 0xff, 0xff, 0x51, 0x26, 0xaf, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x1e, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x6, 0xff, 0xff, 0x50, 0x0, + 0x1, 0x8f, 0xff, 0xff, 0xd1, 0x0, 0x0, 0xaf, + 0xff, 0xfe, 0x30, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x4, 0xff, 0xff, 0xfa, 0x0, + 0x3, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0x30, 0xb, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xb0, 0x1f, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xf0, 0x6f, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf5, + 0x9f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xf8, 0xcf, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xfa, 0xdf, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfb, 0xef, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xfc, + 0xef, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xfc, 0xdf, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xfa, 0xaf, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf8, 0x7f, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf4, + 0x2f, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xf0, 0xc, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xa0, 0x5, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0x30, 0x0, 0xbf, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x4, 0xef, 0xff, 0xf9, 0x0, + 0x0, 0x1e, 0xff, 0xff, 0xf9, 0x10, 0x0, 0x6, + 0xff, 0xff, 0x50, 0x0, 0x1, 0x8f, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xfa, + 0x62, 0x16, 0xff, 0xff, 0x51, 0x26, 0xaf, 0xff, + 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, 0x2d, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x59, + 0xcd, 0xef, 0xff, 0xff, 0xfe, 0xdb, 0x84, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A7 "Χ" */ + 0x0, 0xcf, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xfb, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xe1, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0x30, 0x0, 0x4, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xd0, 0x0, 0x1e, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xf8, 0x0, 0xbf, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0x36, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xce, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x3d, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf8, 0x4, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xd0, 0x0, + 0x9f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x20, + 0x0, 0xd, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xf6, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x80, + 0x0, 0x1, 0xdf, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xf4, 0x0, 0xa, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xfe, 0x10, 0x6f, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xa0, + + /* U+03A8 "Ψ" */ + 0xef, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xfa, 0xef, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xfa, 0xef, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfa, 0xef, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfa, + 0xef, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xfa, 0xef, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xfa, 0xef, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfa, 0xef, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfa, + 0xef, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xfa, 0xef, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xfa, 0xef, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfa, 0xdf, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf9, + 0xcf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xf8, 0xbf, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf7, 0x8f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf3, 0x4f, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf0, + 0xf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xc0, 0x9, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0x50, 0x2, 0xff, 0xff, 0xfc, + 0x10, 0x0, 0x0, 0x8, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x3, 0xef, 0xff, 0xfd, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf7, 0x10, 0x0, 0x8, 0xff, 0xff, + 0x40, 0x0, 0x1, 0x8f, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xfb, 0x74, 0x18, + 0xff, 0xff, 0x53, 0x47, 0xbf, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x1, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0x8b, 0xde, 0xff, + 0xff, 0xff, 0xfe, 0xdc, 0xa6, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A9 "Ω" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x56, + 0x77, 0x64, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6b, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x93, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6e, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1b, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, + 0xff, 0xff, 0xff, 0xec, 0xab, 0xcf, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xff, 0x82, 0x0, 0x0, 0x0, 0x5c, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xb1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xf6, 0x0, 0x5, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xfc, 0x0, 0x9, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0x10, 0xd, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0x30, 0xf, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x60, 0x2f, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x80, + 0x2f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0x90, 0x3f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xa0, 0x3f, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0x90, 0x2f, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0x80, 0xf, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0x60, 0xd, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0x30, 0x9, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x0, 0x4, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xfb, 0x0, + 0x0, 0xef, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf5, + 0x0, 0x0, 0x8f, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xe0, 0x0, 0x0, 0x1e, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0x60, 0x0, 0x0, 0x6, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xef, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xef, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2e, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3e, 0xff, 0xfc, 0x10, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x24, 0x44, 0x44, 0x47, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x3, 0xcf, 0xff, 0xfb, 0x44, 0x44, 0x44, + 0x40, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x50, 0x0, 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x50, 0x0, 0xe, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf0, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x50, 0x0, 0xe, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf0, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x50, 0x0, 0xe, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf0, + + /* U+03AA "Ϊ" */ + 0xf, 0xff, 0xf9, 0x0, 0x0, 0xef, 0xff, 0xa0, + 0xff, 0xff, 0x90, 0x0, 0xe, 0xff, 0xfa, 0xf, + 0xff, 0xf9, 0x0, 0x0, 0xef, 0xff, 0xa0, 0xff, + 0xff, 0x90, 0x0, 0xe, 0xff, 0xfa, 0xf, 0xff, + 0xf9, 0x0, 0x0, 0xef, 0xff, 0xa0, 0x11, 0x11, + 0x0, 0x0, 0x1, 0x11, 0x11, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf4, + 0x0, 0x0, + + /* U+03AB "Ϋ" */ + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x50, + 0x0, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf5, + 0x0, 0x2, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0x50, 0x0, 0x2f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xf5, 0x0, 0x2, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0x50, 0x0, 0x2f, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x11, 0x10, 0x0, 0x0, 0x11, 0x11, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0x90, 0xdf, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xd0, 0x3, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xf3, 0x0, 0x8, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xf8, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x1f, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xfe, 0x10, 0x0, 0xb, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf9, 0x0, 0x5, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xf3, 0x0, 0xef, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xc0, 0x8f, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0x8f, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03AC "ά" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x46, 0x77, 0x52, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3b, 0xff, 0xff, + 0xff, 0xfd, 0x40, 0x0, 0xa, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x90, 0x0, 0xef, 0xff, 0x90, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x3f, + 0xff, 0xf4, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xe8, + 0x43, 0x59, 0xef, 0xff, 0x78, 0xff, 0xff, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0x90, 0x0, 0x0, 0x1, + 0xbf, 0xff, 0xef, 0xff, 0xc0, 0x0, 0xc, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xf7, 0x0, 0x2, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x8f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xf0, 0x0, 0xc, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xfc, 0x0, 0x0, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x90, + 0x0, 0x1f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf5, 0x0, 0x2, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x20, 0x0, 0x3f, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf0, + 0x0, 0x3, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0x0, 0x0, 0x2f, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xf2, 0x0, 0x1, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0x50, 0x0, 0xe, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf8, 0x0, 0x0, + 0xbf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xb0, 0x0, 0x7, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0x0, 0x0, 0x1f, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0xbf, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x2e, 0xff, 0xff, 0xff, 0x60, 0x0, 0x2, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x3e, 0xff, 0xed, + 0xff, 0xfa, 0x0, 0x0, 0x7, 0xff, 0xff, 0xfc, + 0x63, 0x35, 0xaf, 0xff, 0xf6, 0x8f, 0xff, 0xe0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x4, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0xe, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x2, 0xaf, + 0xff, 0xff, 0xff, 0xd6, 0x0, 0x0, 0x8f, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x67, 0x75, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03AD "έ" */ + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xd1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x14, 0x67, 0x65, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4b, 0xff, 0xff, 0xff, 0xfe, 0x81, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x1, 0xff, + 0xff, 0xfb, 0x76, 0x7a, 0xff, 0xff, 0xf8, 0x0, + 0x8, 0xff, 0xff, 0x50, 0x0, 0x0, 0x17, 0xff, + 0x50, 0x0, 0xc, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x12, 0x0, 0x0, 0xe, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xe6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xfd, 0xbb, 0x30, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xdf, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xdf, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xfa, + 0x41, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x2, 0x20, 0x0, + 0x5f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x2e, + 0xe3, 0x0, 0x1f, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x6, 0xff, 0xff, 0x50, 0x8, 0xff, 0xff, 0xfa, + 0x43, 0x47, 0xdf, 0xff, 0xff, 0xd0, 0x0, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x10, + 0x0, 0x1c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x7e, 0xff, 0xff, 0xff, + 0xfe, 0x81, 0x0, 0x0, 0x0, 0x0, 0x0, 0x25, + 0x67, 0x75, 0x20, 0x0, 0x0, 0x0, + + /* U+03AE "ή" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x46, 0x77, + 0x52, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x50, 0x3, + 0xbf, 0xff, 0xff, 0xff, 0xd5, 0x0, 0x0, 0x9f, + 0xff, 0x50, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0x9f, 0xff, 0x59, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x0, 0x9f, 0xff, 0xbf, + 0xff, 0xfb, 0x76, 0x7a, 0xef, 0xff, 0xff, 0x60, + 0x9f, 0xff, 0xff, 0xfa, 0x10, 0x0, 0x0, 0x1b, + 0xff, 0xff, 0xd0, 0x9f, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xf1, 0x9f, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xf4, 0x9f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xf5, 0x9f, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf6, 0x9f, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf7, 0x9f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf7, 0x9f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf7, + 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf7, 0x9f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf7, 0x9f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf7, 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf7, 0x9f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf7, 0x9f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf7, 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf7, 0x9f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf7, + 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf7, 0x9f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf7, 0x9f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf7, 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf7, 0x9f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf7, 0x9f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf7, + + /* U+03AF "ί" */ + 0x0, 0x6, 0xff, 0xff, 0xf4, 0x0, 0xd, 0xff, + 0xff, 0x70, 0x0, 0x4f, 0xff, 0xfb, 0x0, 0x0, + 0xcf, 0xff, 0xd1, 0x0, 0x3, 0xff, 0xff, 0x30, + 0x0, 0xb, 0xff, 0xf6, 0x0, 0x0, 0x2f, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfb, 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, + 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, 0xa, 0xff, + 0xfb, 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, + 0xa, 0xff, 0xfb, 0x0, 0x0, 0xa, 0xff, 0xfb, + 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, 0xa, + 0xff, 0xfb, 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, + 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, 0xa, 0xff, + 0xfb, 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, + 0xa, 0xff, 0xfb, 0x0, 0x0, 0xa, 0xff, 0xfb, + 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, 0xa, + 0xff, 0xfb, 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, + 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, 0xa, 0xff, + 0xfb, 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, + 0xa, 0xff, 0xfb, 0x0, 0x0, 0xa, 0xff, 0xfb, + 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, 0xa, + 0xff, 0xfb, 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, + 0x0, + + /* U+03B0 "ΰ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x28, 0x88, 0x81, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x2, 0xcc, + 0xcc, 0x0, 0x2, 0xff, 0xfd, 0x7, 0xcc, 0xc7, + 0x0, 0x2, 0xff, 0xff, 0x10, 0xa, 0xff, 0xf2, + 0xa, 0xff, 0xf9, 0x0, 0x2, 0xff, 0xff, 0x10, + 0x2f, 0xff, 0x60, 0xa, 0xff, 0xf9, 0x0, 0x2, + 0xff, 0xff, 0x10, 0x9f, 0xfa, 0x0, 0xa, 0xff, + 0xf9, 0x0, 0x2, 0xff, 0xff, 0x12, 0xff, 0xd0, + 0x0, 0xa, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf1, 0xaf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf1, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xf1, 0xaf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf1, + 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xf1, 0xaf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf1, 0xaf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xf1, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf1, 0xaf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf1, 0xaf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf1, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xf1, 0xaf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf1, + 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xf1, 0xaf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf1, 0xaf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xf1, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf0, 0xaf, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf0, 0x9f, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xe0, 0x7f, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xc0, 0x4f, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x80, + 0xe, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0x30, 0x8, 0xff, 0xff, 0xd2, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xfc, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0x94, 0x33, 0x7e, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x2, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe4, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xdf, 0xff, 0xff, 0xff, 0xe7, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x57, 0x76, + 0x52, 0x0, 0x0, 0x0, 0x0, + + /* U+03B1 "α" */ + 0x0, 0x0, 0x0, 0x0, 0x4, 0x67, 0x75, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xbf, 0xff, 0xff, 0xff, 0xd4, 0x0, 0x0, + 0xaf, 0xff, 0xe0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0xe, 0xff, 0xf9, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x3, 0xff, 0xff, 0x40, 0x0, 0x9, + 0xff, 0xff, 0xfe, 0x84, 0x35, 0x9e, 0xff, 0xf7, + 0x8f, 0xff, 0xf0, 0x0, 0x4, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x1b, 0xff, 0xfe, 0xff, 0xfc, + 0x0, 0x0, 0xcf, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0x70, 0x0, 0x2f, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xf4, 0x0, 0x8, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0x0, 0x0, 0xcf, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xc0, 0x0, 0xf, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xf9, 0x0, 0x1, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x50, 0x0, 0x2f, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf2, 0x0, 0x3, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x0, 0x0, 0x3f, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf0, 0x0, 0x2, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x20, 0x0, + 0x1f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf5, 0x0, 0x0, 0xef, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x80, 0x0, 0xb, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, 0x0, + 0x0, 0x7f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xf0, 0x0, 0x1, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0x20, 0x0, 0xb, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x3, 0xef, 0xfe, 0xdf, 0xff, 0xa0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xc6, 0x33, 0x5a, 0xff, 0xff, + 0x68, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x4f, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0xef, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x2a, 0xff, 0xff, 0xff, 0xfd, 0x60, + 0x0, 0x8, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x46, 0x77, 0x52, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+03B2 "β" */ + 0x0, 0x0, 0x0, 0x0, 0x25, 0x77, 0x65, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x8e, + 0xff, 0xff, 0xff, 0xfd, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x10, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd1, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xb5, 0x33, 0x59, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x3, 0xff, 0xff, 0xe3, + 0x0, 0x0, 0x0, 0x1c, 0xff, 0xff, 0x40, 0x0, + 0xb, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xc0, 0x0, 0xf, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf1, 0x0, + 0x4f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xf3, 0x0, 0x6f, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf5, 0x0, + 0x8f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf4, 0x0, 0x8f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf1, 0x0, + 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xc0, 0x0, 0x9f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0x40, 0x0, + 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x6e, + 0xff, 0xf7, 0x0, 0x0, 0x9f, 0xff, 0xc0, 0x0, + 0x14, 0x57, 0xae, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x9f, 0xff, 0xc0, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0x92, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xc0, 0x0, + 0x5f, 0xff, 0xff, 0xfa, 0x72, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xc0, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xb2, 0x0, 0x0, 0x9f, 0xff, 0xc0, 0x0, + 0x0, 0x1, 0x37, 0xcf, 0xff, 0xff, 0x50, 0x0, + 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xef, 0xff, 0xf5, 0x0, 0x9f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x10, + 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0x90, 0x9f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf0, + 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xf3, 0x9f, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf6, + 0x9f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf7, 0x9f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf6, + 0x9f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xf5, 0x9f, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf1, + 0x9f, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xd0, 0x9f, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x60, + 0x9f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xfe, 0x0, 0x9f, 0xff, 0xef, 0xff, + 0xe6, 0x0, 0x0, 0x28, 0xff, 0xff, 0xf4, 0x0, + 0x9f, 0xff, 0xc5, 0xff, 0xff, 0xfd, 0xce, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x9f, 0xff, 0xc0, 0x5e, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x9f, 0xff, 0xc0, 0x1, 0x9e, 0xff, 0xff, 0xff, + 0xe9, 0x10, 0x0, 0x0, 0x9f, 0xff, 0xc0, 0x0, + 0x0, 0x35, 0x77, 0x53, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+03B3 "γ" */ + 0x3f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0x30, 0xdf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xd0, 0x7, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf7, 0x0, 0x1f, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0x10, 0x0, 0xbf, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xb0, 0x0, 0x5, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xf5, 0x0, 0x0, 0xf, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x90, 0x0, 0x0, 0x4, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x4f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xfa, 0x0, 0x0, 0xa, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf0, + 0x0, 0x0, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0x50, 0x0, 0x5f, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xfb, 0x0, 0xb, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf1, 0x1, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0x60, 0x7f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xfc, 0xc, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf4, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xef, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+03B4 "δ" */ + 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xfb, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0x70, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xef, 0xff, 0xe4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1c, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xd3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3d, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x7c, 0xef, + 0xff, 0xff, 0xfb, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xc8, 0x66, + 0x8d, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xd3, 0x0, 0x0, 0x0, 0x5e, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x8f, 0xff, 0xfd, 0x10, + 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0xe1, 0x0, + 0x0, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xfa, 0x0, 0x6, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x20, 0xa, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x70, 0xe, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xb0, 0x1f, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xe0, 0x2f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf0, 0x3f, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xf0, 0x3f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf0, + 0x2f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xf0, 0xf, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xe0, 0xd, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xc0, 0xa, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x80, 0x5, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x40, 0x0, 0xef, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xfe, 0x0, 0x0, 0x7f, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf7, 0x0, 0x0, 0xd, 0xff, 0xff, 0xc2, + 0x0, 0x0, 0x0, 0x2c, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xa5, 0x33, 0x5a, + 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe3, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xdf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xcf, 0xff, 0xff, 0xff, 0xfb, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x46, 0x77, 0x53, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+03B5 "ε" */ + 0x0, 0x0, 0x0, 0x14, 0x67, 0x65, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4b, 0xff, 0xff, 0xff, + 0xfe, 0x81, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x1, 0xff, 0xff, 0xfb, 0x76, 0x7a, 0xff, 0xff, + 0xf8, 0x0, 0x8, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x17, 0xff, 0x50, 0x0, 0xc, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x12, 0x0, 0x0, 0xe, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xe6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xfd, 0xbb, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xdf, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xdf, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xfa, 0x41, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x20, 0x0, 0x5f, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x2e, 0xe3, 0x0, 0x1f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x6, 0xff, 0xff, 0x50, 0x8, 0xff, + 0xff, 0xfa, 0x43, 0x47, 0xdf, 0xff, 0xff, 0xd0, + 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x10, 0x0, 0x1c, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x7e, 0xff, + 0xff, 0xff, 0xfe, 0x81, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x25, 0x67, 0x75, 0x20, 0x0, 0x0, 0x0, + + /* U+03B6 "ζ" */ + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x2, 0xaa, 0xaa, 0xaa, 0xaa, 0xac, 0xff, + 0xff, 0xc2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xfe, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xfd, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1c, 0xff, + 0xfc, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xfd, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xc1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0xf9, 0x53, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xa7, + 0x20, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x28, 0xce, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x13, 0x9f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xbe, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xe3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfe, + 0x91, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x26, 0x53, 0x0, 0x0, 0x0, 0x0, + + /* U+03B7 "η" */ + 0x0, 0x0, 0x0, 0x0, 0x1, 0x46, 0x77, 0x52, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0x50, 0x3, 0xbf, + 0xff, 0xff, 0xff, 0xd5, 0x0, 0x0, 0x9f, 0xff, + 0x50, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x9f, 0xff, 0x59, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x0, 0x9f, 0xff, 0xbf, 0xff, + 0xfb, 0x76, 0x7a, 0xef, 0xff, 0xff, 0x60, 0x9f, + 0xff, 0xff, 0xfa, 0x10, 0x0, 0x0, 0x1b, 0xff, + 0xff, 0xd0, 0x9f, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xf1, 0x9f, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf4, + 0x9f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf5, 0x9f, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf6, 0x9f, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf7, 0x9f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf7, 0x9f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf7, 0x9f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf7, 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf7, 0x9f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf7, + 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf7, 0x9f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf7, 0x9f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf7, 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf7, 0x9f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf7, 0x9f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf7, 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf7, 0x9f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf7, + 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf7, 0x9f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf7, 0x9f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf7, + + /* U+03B8 "θ" */ + 0x0, 0x0, 0x0, 0x0, 0x4, 0x67, 0x76, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2a, + 0xff, 0xff, 0xff, 0xff, 0x91, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xfb, 0x53, 0x36, 0xcf, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x7, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x9f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xf6, 0x0, 0x0, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfd, 0x0, + 0x5, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0x30, 0xa, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x80, + 0xe, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xc0, 0x2f, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf0, + 0x4f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf2, 0x6f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf4, + 0x8f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf6, 0xaf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf7, + 0xbf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf8, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0xbf, 0xff, 0xe9, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x99, 0x9f, 0xff, 0xf8, 0xbf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf8, + 0xaf, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf7, 0x8f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf6, + 0x7f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xf4, 0x4f, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf2, + 0x2f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf0, 0xe, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xc0, + 0xa, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x80, 0x6, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x30, + 0x0, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xfd, 0x0, 0x0, 0x9f, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf6, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xfb, 0x53, 0x36, 0xcf, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2a, 0xff, 0xff, 0xff, 0xff, + 0x91, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0x67, 0x76, 0x30, 0x0, 0x0, 0x0, 0x0, + + /* U+03B9 "ι" */ + 0xaf, 0xff, 0xba, 0xff, 0xfb, 0xaf, 0xff, 0xba, + 0xff, 0xfb, 0xaf, 0xff, 0xba, 0xff, 0xfb, 0xaf, + 0xff, 0xba, 0xff, 0xfb, 0xaf, 0xff, 0xba, 0xff, + 0xfb, 0xaf, 0xff, 0xba, 0xff, 0xfb, 0xaf, 0xff, + 0xba, 0xff, 0xfb, 0xaf, 0xff, 0xba, 0xff, 0xfb, + 0xaf, 0xff, 0xba, 0xff, 0xfb, 0xaf, 0xff, 0xba, + 0xff, 0xfb, 0xaf, 0xff, 0xba, 0xff, 0xfb, 0xaf, + 0xff, 0xba, 0xff, 0xfb, 0xaf, 0xff, 0xba, 0xff, + 0xfb, + + /* U+03BA "κ" */ + 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0x60, 0xbf, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xf5, 0x0, 0xbf, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x50, + 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, + 0x0, 0x7f, 0xff, 0xfe, 0x30, 0x0, 0x0, 0xbf, + 0xff, 0xa0, 0x0, 0x8, 0xff, 0xff, 0xe2, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x8f, 0xff, + 0xfd, 0x20, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xa0, + 0x9, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xa0, 0x9f, 0xff, 0xfc, 0x10, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xa9, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xfd, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf7, 0x3f, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xa0, + 0x5, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xa0, 0x0, 0x7f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, 0xa, + 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xa0, 0x0, 0x0, 0xcf, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0x90, 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xf6, 0x0, 0x0, 0xbf, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0x40, 0x0, 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xe2, 0x0, 0xbf, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfd, 0x0, + 0xbf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xb0, 0xbf, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xef, 0xff, 0xf8, + + /* U+03BB "λ" */ + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xcf, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xf2, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xfa, 0xb, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0x40, 0x5f, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xe0, + 0x0, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf8, 0x0, 0x9, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0x20, 0x0, 0x3f, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xc0, 0x0, 0x0, 0xdf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xf7, 0x0, 0x0, 0x8, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x2f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0x30, 0x0, 0x0, 0x9, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0xef, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xe0, 0x0, 0x0, + 0x5f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0x50, 0x0, 0xb, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfa, 0x0, + 0x1, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf1, 0x0, 0x7f, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x60, 0xd, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xfc, 0x3, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xf2, + + /* U+03BC "μ" */ + 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf5, 0x9f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf5, 0x9f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf5, 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf5, 0x9f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf5, 0x9f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf5, 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf5, 0x9f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf5, + 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf5, 0x9f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf5, 0x9f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf5, 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf5, 0x9f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf5, 0x9f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf5, 0x9f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf5, 0x9f, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf5, + 0x9f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xf5, 0x9f, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf5, 0x9f, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xf5, 0x9f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xf5, 0x9f, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf5, 0x9f, + 0xff, 0xff, 0xf9, 0x10, 0x0, 0x3, 0xcf, 0xff, + 0xff, 0xf5, 0x9f, 0xff, 0xff, 0xff, 0xfb, 0x99, + 0xdf, 0xff, 0xff, 0xff, 0xf5, 0x9f, 0xff, 0xde, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd9, 0xff, 0xf5, + 0x9f, 0xff, 0xc2, 0xef, 0xff, 0xff, 0xff, 0xfd, + 0x29, 0xff, 0xf5, 0x9f, 0xff, 0xc0, 0x1a, 0xff, + 0xff, 0xff, 0xa1, 0x9, 0xff, 0xf5, 0x9f, 0xff, + 0xc0, 0x0, 0x15, 0x76, 0x51, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+03BD "ν" */ + 0x2f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0x30, 0xcf, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xd0, 0x6, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf7, 0x0, 0x1f, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0x10, 0x0, 0xaf, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xb0, 0x0, 0x4, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xf5, 0x0, 0x0, 0xe, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x90, 0x0, 0x0, 0x2, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0xef, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x4f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xfb, 0x0, 0x0, 0xa, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf1, + 0x0, 0x0, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x70, 0x0, 0x5f, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xfd, 0x0, 0xb, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf2, 0x1, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x70, 0x7f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfc, 0xc, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf3, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xcf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03BE "ξ" */ + 0x0, 0x0, 0x0, 0x0, 0x37, 0x9a, 0xbb, 0xbb, + 0x90, 0x0, 0x0, 0x0, 0x1, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xb6, 0x31, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xe3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xd2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xa5, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x3d, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x38, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xdc, + 0x60, 0x0, 0x0, 0x0, 0x1c, 0xff, 0xff, 0xd8, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xfe, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xfd, 0x51, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xda, + 0x85, 0x20, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x40, 0x0, 0x0, 0x0, + 0x6e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x6b, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x3, 0x58, + 0xbf, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xbf, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0x6c, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xd2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xfe, 0xb7, 0x10, 0x0, 0x0, + + /* U+03BF "ο" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x46, 0x77, 0x54, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xbf, 0xff, 0xff, 0xff, 0xfb, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe2, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xa5, 0x34, 0x6a, 0xff, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xb1, 0x0, 0x0, + 0x0, 0x2c, 0xff, 0xff, 0xc0, 0x0, 0x0, 0xaf, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xf6, 0x0, 0x2, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfd, 0x0, + 0x7, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0x40, 0xb, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x80, 0xf, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xc0, 0x1f, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xe0, 0x2f, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xf0, 0x3f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf0, 0x3f, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xf0, 0x2f, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xe0, + 0x1f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xd0, 0xf, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xb0, 0xb, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x70, 0x7, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0x30, 0x1, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfd, + 0x0, 0x0, 0xaf, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xf6, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xa1, 0x0, 0x0, 0x0, 0x2c, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0x95, 0x33, 0x5a, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xcf, 0xff, + 0xff, 0xff, 0xfb, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x46, 0x77, 0x54, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+03C0 "π" */ + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x6e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf6, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x69, 0xaa, 0xaa, 0xaa, 0xff, 0xff, 0xca, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaf, 0xff, 0xfd, 0xaa, + 0xaa, 0xa4, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf8, 0x0, 0x0, 0x0, + + /* U+03C1 "ρ" */ + 0x0, 0x0, 0x0, 0x0, 0x25, 0x67, 0x65, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7d, + 0xff, 0xff, 0xff, 0xfd, 0x81, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x60, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xe9, 0x53, 0x47, 0xcf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0xcf, 0xff, 0xfb, + 0x10, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf4, 0x0, + 0x5, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xfe, 0x0, 0xb, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x60, + 0xf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xd0, 0x3f, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf1, + 0x6f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xf5, 0x9f, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf8, + 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf9, 0xbf, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xfa, + 0xcf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xfa, 0xcf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf9, + 0xcf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf8, 0xcf, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf5, + 0xcf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xf1, 0xcf, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xd0, + 0xcf, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0x60, 0xcf, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, 0x0, + 0xcf, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x4, + 0xef, 0xff, 0xf6, 0x0, 0xcf, 0xff, 0xff, 0xff, + 0xe8, 0x43, 0x36, 0xbf, 0xff, 0xff, 0xa0, 0x0, + 0xcf, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0xcf, 0xff, 0x93, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0xcf, 0xff, 0x90, 0x8, 0xef, 0xff, 0xff, 0xff, + 0xa3, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x90, 0x0, + 0x2, 0x57, 0x76, 0x40, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+03C2 "ς" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x36, 0x77, + 0x75, 0x41, 0x0, 0x0, 0x0, 0x0, 0x0, 0x17, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xe5, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x3, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xfc, 0x75, 0x43, 0x56, 0x9d, 0xb0, 0x0, + 0x3, 0xff, 0xff, 0xf9, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xfe, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xfd, 0x61, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xff, 0xc8, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5e, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x1, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x6b, 0xff, 0xff, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x7c, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3e, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x21, + 0x0, 0x27, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xff, 0xc2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xfe, 0xa4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x21, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03C3 "σ" */ + 0x0, 0x0, 0x0, 0x0, 0x1, 0x46, 0x77, 0x63, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5c, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x3, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x6, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x0, 0x5, 0xff, 0xff, 0xfe, 0x95, + 0x34, 0x6b, 0xff, 0xff, 0xff, 0xaa, 0xaa, 0xaa, + 0x70, 0x3, 0xff, 0xff, 0xf9, 0x10, 0x0, 0x0, + 0x2, 0xcf, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x10, 0x0, 0x0, 0xdf, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf6, 0x0, + 0x0, 0xf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x90, 0x0, 0x2, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xfc, 0x0, 0x0, 0x3f, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xd0, 0x0, 0x4, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xfe, 0x0, 0x0, 0x5f, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xe0, + 0x0, 0x3, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xfd, 0x0, 0x0, + 0x2f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xc0, 0x0, 0x0, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xfa, 0x0, 0x0, 0xd, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x9f, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf3, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x2c, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xe8, 0x43, 0x35, 0xaf, 0xff, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4e, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xcf, 0xff, 0xff, + 0xff, 0xea, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x14, 0x67, 0x75, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03C4 "τ" */ + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf9, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf9, 0x8a, 0xaa, 0xaa, 0xaf, 0xff, + 0xfc, 0xaa, 0xaa, 0xa6, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf5, 0x0, + 0x0, 0x0, + + /* U+03C5 "υ" */ + 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xf1, 0xaf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf1, 0xaf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xf1, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf1, 0xaf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf1, 0xaf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf1, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xf1, 0xaf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf1, + 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xf1, 0xaf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf1, 0xaf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xf1, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf1, 0xaf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf1, 0xaf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf1, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xf1, 0xaf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf0, + 0xaf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xf0, 0x9f, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xe0, 0x7f, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xc0, 0x4f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0x80, 0xe, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x30, 0x8, + 0xff, 0xff, 0xd2, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xfc, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x94, 0x33, + 0x7e, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x2e, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x2, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe4, 0x0, 0x0, 0x0, 0x0, 0x6, 0xdf, 0xff, + 0xff, 0xff, 0xe7, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0x57, 0x76, 0x52, 0x0, 0x0, 0x0, + 0x0, + + /* U+03C6 "φ" */ + 0x0, 0x0, 0x0, 0x0, 0x4, 0x61, 0x0, 0x0, + 0x25, 0x77, 0x63, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2a, 0xff, 0xf0, 0x0, 0x1b, 0xff, + 0xff, 0xff, 0xf9, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xb0, 0x0, 0xdf, 0xff, 0xff, + 0xff, 0xff, 0xe4, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0x80, 0x5, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xfa, 0x20, 0x9, 0xff, 0xff, 0xc5, 0x49, 0xff, + 0xff, 0xe1, 0x0, 0x0, 0x2f, 0xff, 0xfe, 0x30, + 0x0, 0xb, 0xff, 0xff, 0x0, 0x0, 0x3f, 0xff, + 0xfa, 0x0, 0x0, 0xbf, 0xff, 0xf2, 0x0, 0x0, + 0xc, 0xff, 0xfb, 0x0, 0x0, 0x5, 0xff, 0xff, + 0x30, 0x2, 0xff, 0xff, 0x70, 0x0, 0x0, 0xc, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xa0, + 0x8, 0xff, 0xff, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf0, 0xc, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf4, 0xf, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf7, 0x1f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf9, 0x2f, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xfa, 0x3f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf9, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xfa, 0x2f, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf9, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf9, 0xf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf6, + 0xe, 0xff, 0xfb, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf3, 0xa, + 0xff, 0xff, 0x10, 0x0, 0x0, 0xc, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xe0, 0x6, 0xff, + 0xff, 0x70, 0x0, 0x0, 0xc, 0xff, 0xf9, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x90, 0x1, 0xef, 0xff, + 0xf1, 0x0, 0x0, 0xc, 0xff, 0xf9, 0x0, 0x0, + 0xc, 0xff, 0xff, 0x20, 0x0, 0x7f, 0xff, 0xfb, + 0x0, 0x0, 0xc, 0xff, 0xf9, 0x0, 0x0, 0x8f, + 0xff, 0xf9, 0x0, 0x0, 0xd, 0xff, 0xff, 0xa0, + 0x0, 0xc, 0xff, 0xf9, 0x0, 0x7, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xfd, 0x40, + 0xc, 0xff, 0xf9, 0x2, 0xbf, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfd, 0x8d, + 0xff, 0xfc, 0xcf, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2b, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xa1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5c, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x92, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x15, 0x6e, 0xff, 0xfc, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+03C7 "χ" */ + 0x9, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xf1, 0x1, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0x70, 0x0, 0x8f, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xfe, 0x0, 0x0, + 0x1f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x8, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0x20, 0x0, 0x0, + 0xdf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xa0, 0x0, 0x6, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf2, + 0x0, 0xe, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xfa, 0x0, 0x6f, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0x20, 0xef, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xa7, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xfe, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xda, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0x42, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xfc, 0x0, 0x9f, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf4, 0x0, 0x2f, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xc0, 0x0, 0x9, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x30, + 0x0, 0x1, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0x30, 0x0, 0x0, 0x8, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x2f, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf4, 0x0, + 0x0, 0xaf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xfd, 0x0, 0x3, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0x60, 0xc, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xe0, 0x4f, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xf8, + + /* U+03C8 "ψ" */ + 0xf, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xa0, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xfa, 0xf, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xa0, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xfa, 0xf, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xa0, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xfa, 0xf, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xa0, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xfa, 0xf, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xa0, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xfa, 0xf, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xa0, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xfa, 0xf, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xa0, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xf9, 0xf, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0x90, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf8, + 0xd, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x70, + 0xcf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf5, 0x9, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x20, 0x5f, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xe0, 0x0, 0xef, + 0xff, 0xf4, 0x0, 0x0, 0x6, 0xff, 0xff, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xf9, 0x0, 0x5, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x6f, 0xff, 0xf0, 0x0, + 0x2, 0xbf, 0xff, 0xff, 0x20, 0x0, 0xa, 0xff, + 0xff, 0xfe, 0xa6, 0x48, 0xff, 0xff, 0x45, 0x7b, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x6, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7c, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x45, 0x6a, 0xff, 0xff, 0x76, 0x53, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03C9 "ω" */ + 0x0, 0x4, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xc0, 0x0, 0x0, 0x4f, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x40, 0x0, 0xb, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xfc, 0x0, 0x1, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf2, 0x0, + 0x7f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0x80, 0xd, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x5, 0x77, 0x75, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xfd, 0x1, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xf1, 0x4f, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x58, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf8, 0xaf, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xbb, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xfc, 0xdf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xdd, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xfe, 0xdf, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xdc, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfc, + 0xaf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xb7, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf8, 0x4f, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0x50, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf1, 0xa, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0xdf, 0xfe, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfb, 0x0, + 0x2f, 0xff, 0xfe, 0x10, 0x0, 0x0, 0xbf, 0xff, + 0x3f, 0xff, 0xb0, 0x0, 0x0, 0x1d, 0xff, 0xff, + 0x40, 0x0, 0x9f, 0xff, 0xfe, 0x61, 0x4, 0xcf, + 0xff, 0x90, 0x8f, 0xff, 0xc4, 0x1, 0x5e, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd1, 0x0, 0x0, 0x1, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xd1, 0x0, 0x1, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, 0x0, + 0x7e, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xfe, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0x67, 0x74, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0x77, 0x63, 0x0, 0x0, 0x0, + 0x0, + + /* U+03CA "ϊ" */ + 0x5f, 0xff, 0xf4, 0x0, 0x3, 0xff, 0xff, 0x55, + 0xff, 0xff, 0x40, 0x0, 0x3f, 0xff, 0xf5, 0x5f, + 0xff, 0xf4, 0x0, 0x3, 0xff, 0xff, 0x55, 0xff, + 0xff, 0x40, 0x0, 0x3f, 0xff, 0xf5, 0x5f, 0xff, + 0xf4, 0x0, 0x3, 0xff, 0xff, 0x50, 0x11, 0x11, + 0x0, 0x0, 0x1, 0x11, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xb0, 0x0, 0x0, + + /* U+03CB "ϋ" */ + 0x0, 0x2, 0xff, 0xff, 0x60, 0x0, 0x1f, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x60, + 0x0, 0x1f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0x60, 0x0, 0x1f, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0x60, 0x0, 0x1f, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0x60, 0x0, 0x1f, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x11, 0x11, 0x0, 0x0, 0x1, 0x11, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xf1, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf1, 0xaf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf1, 0xaf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf1, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xf1, 0xaf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf1, + 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xf1, 0xaf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf1, 0xaf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xf1, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf1, 0xaf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf1, 0xaf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf1, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xf1, 0xaf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf1, + 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xf1, 0xaf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf0, 0xaf, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xf0, 0x9f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xe0, 0x7f, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xc0, 0x4f, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0x80, 0xe, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0x30, 0x8, 0xff, 0xff, + 0xd2, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfc, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0x94, 0x33, 0x7e, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x2, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe4, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xdf, 0xff, 0xff, 0xff, + 0xe7, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x57, 0x76, 0x52, 0x0, 0x0, 0x0, 0x0, + + /* U+03CC "ό" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x46, 0x77, 0x54, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xbf, 0xff, 0xff, 0xff, 0xfb, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe2, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xa5, 0x34, 0x6a, 0xff, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xb1, 0x0, 0x0, 0x0, + 0x2c, 0xff, 0xff, 0xc0, 0x0, 0x0, 0xaf, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xf6, 0x0, 0x2, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfd, 0x0, 0x7, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0x40, 0xb, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0x80, 0xf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xc0, 0x1f, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xe0, 0x2f, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf0, + 0x3f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xf0, 0x3f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xf0, 0x2f, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xe0, 0x1f, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xd0, 0xf, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xb0, 0xb, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0x70, 0x7, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0x30, 0x1, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfd, 0x0, + 0x0, 0xaf, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xf6, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xa1, 0x0, 0x0, 0x0, 0x2c, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x95, + 0x33, 0x5a, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, 0x3, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xcf, 0xff, 0xff, + 0xff, 0xfb, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x46, 0x77, 0x54, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+03CD "ύ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf1, 0xaf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf1, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xf1, 0xaf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf1, + 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xf1, 0xaf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf1, 0xaf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xf1, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf1, 0xaf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf1, 0xaf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf1, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xf1, 0xaf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf1, + 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xf1, 0xaf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf1, 0xaf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xf1, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf0, 0xaf, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf0, 0x9f, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xe0, 0x7f, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xc0, 0x4f, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x80, + 0xe, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0x30, 0x8, 0xff, 0xff, 0xd2, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xfc, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0x94, 0x33, 0x7e, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x2, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe4, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xdf, 0xff, 0xff, 0xff, 0xe7, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x57, 0x76, + 0x52, 0x0, 0x0, 0x0, 0x0, + + /* U+03CE "ώ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xc0, 0x0, 0x0, 0x4f, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0x40, 0x0, 0xb, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xfc, 0x0, + 0x1, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xf2, 0x0, 0x7f, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0x80, 0xd, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x5, 0x77, 0x75, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xfd, 0x1, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf1, 0x4f, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x58, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf8, 0xaf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xbb, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xfc, 0xdf, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xdd, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfe, 0xdf, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xdc, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfc, 0xaf, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xb7, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf8, 0x4f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x50, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf1, + 0xa, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0xdf, + 0xfe, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xfb, 0x0, 0x2f, 0xff, 0xfe, 0x10, 0x0, 0x0, + 0xbf, 0xff, 0x3f, 0xff, 0xb0, 0x0, 0x0, 0x1d, + 0xff, 0xff, 0x40, 0x0, 0x9f, 0xff, 0xfe, 0x61, + 0x4, 0xcf, 0xff, 0x90, 0x8f, 0xff, 0xc4, 0x1, + 0x5e, 0xff, 0xff, 0xa0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x1, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xd1, 0x0, 0x1, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xc1, 0x0, 0x0, + 0x0, 0x0, 0x7e, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xfe, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0x67, 0x74, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0x77, 0x63, 0x0, + 0x0, 0x0, 0x0, + + /* U+03F4 "ϴ" */ + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x6c, 0xcc, 0x80, 0x0, 0xaf, + 0xff, 0x40, 0xcc, 0xcc, 0x28, 0xff, 0xfb, 0x0, + 0x2f, 0xff, 0x90, 0xf, 0xff, 0xf3, 0x8f, 0xff, + 0xb0, 0x9, 0xff, 0xd0, 0x0, 0xff, 0xff, 0x38, + 0xff, 0xfb, 0x1, 0xff, 0xf3, 0x0, 0xf, 0xff, + 0xf3, 0x8f, 0xff, 0xb0, 0x7f, 0xf7, 0x0, 0x0, + 0xff, 0xff, 0x30 +}; + + +/*--------------------- + * GLYPH DESCRIPTION + *--------------------*/ + +static const lv_font_fmt_txt_glyph_dsc_t glyph_dsc[] = { + {.bitmap_index = 0, .adv_w = 0, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0} /* id = 0 reserved */, + {.bitmap_index = 0, .adv_w = 222, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 0, .adv_w = 223, .box_w = 6, .box_h = 36, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 108, .adv_w = 284, .box_w = 14, .box_h = 13, .ofs_x = 2, .ofs_y = 23}, + {.bitmap_index = 199, .adv_w = 445, .box_w = 28, .box_h = 39, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 745, .adv_w = 445, .box_w = 25, .box_h = 45, .ofs_x = 1, .ofs_y = -5}, + {.bitmap_index = 1308, .adv_w = 711, .box_w = 39, .box_h = 39, .ofs_x = 3, .ofs_y = -2}, + {.bitmap_index = 2069, .adv_w = 534, .box_w = 31, .box_h = 38, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 2658, .adv_w = 152, .box_w = 6, .box_h = 13, .ofs_x = 2, .ofs_y = 23}, + {.bitmap_index = 2697, .adv_w = 267, .box_w = 12, .box_h = 48, .ofs_x = 3, .ofs_y = -11}, + {.bitmap_index = 2985, .adv_w = 267, .box_w = 13, .box_h = 48, .ofs_x = 1, .ofs_y = -11}, + {.bitmap_index = 3297, .adv_w = 311, .box_w = 17, .box_h = 16, .ofs_x = 1, .ofs_y = 21}, + {.bitmap_index = 3433, .adv_w = 467, .box_w = 25, .box_h = 25, .ofs_x = 2, .ofs_y = 6}, + {.bitmap_index = 3746, .adv_w = 223, .box_w = 6, .box_h = 14, .ofs_x = 4, .ofs_y = -8}, + {.bitmap_index = 3788, .adv_w = 266, .box_w = 15, .box_h = 5, .ofs_x = 1, .ofs_y = 11}, + {.bitmap_index = 3826, .adv_w = 223, .box_w = 6, .box_h = 6, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 3844, .adv_w = 222, .box_w = 14, .box_h = 38, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 4110, .adv_w = 445, .box_w = 24, .box_h = 37, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 4554, .adv_w = 445, .box_w = 14, .box_h = 36, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 4806, .adv_w = 445, .box_w = 25, .box_h = 36, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 5256, .adv_w = 445, .box_w = 24, .box_h = 37, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 5700, .adv_w = 445, .box_w = 26, .box_h = 36, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 6168, .adv_w = 445, .box_w = 24, .box_h = 37, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 6612, .adv_w = 445, .box_w = 24, .box_h = 37, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 7056, .adv_w = 445, .box_w = 24, .box_h = 36, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 7488, .adv_w = 445, .box_w = 24, .box_h = 37, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 7932, .adv_w = 445, .box_w = 24, .box_h = 37, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 8376, .adv_w = 223, .box_w = 6, .box_h = 26, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 8454, .adv_w = 223, .box_w = 6, .box_h = 34, .ofs_x = 4, .ofs_y = -8}, + {.bitmap_index = 8556, .adv_w = 467, .box_w = 25, .box_h = 26, .ofs_x = 2, .ofs_y = 5}, + {.bitmap_index = 8881, .adv_w = 467, .box_w = 25, .box_h = 16, .ofs_x = 2, .ofs_y = 10}, + {.bitmap_index = 9081, .adv_w = 467, .box_w = 25, .box_h = 26, .ofs_x = 2, .ofs_y = 5}, + {.bitmap_index = 9406, .adv_w = 445, .box_w = 24, .box_h = 37, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 9850, .adv_w = 812, .box_w = 48, .box_h = 48, .ofs_x = 2, .ofs_y = -11}, + {.bitmap_index = 11002, .adv_w = 534, .box_w = 35, .box_h = 36, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 11632, .adv_w = 534, .box_w = 28, .box_h = 36, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 12136, .adv_w = 578, .box_w = 33, .box_h = 38, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 12763, .adv_w = 578, .box_w = 31, .box_h = 36, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 13321, .adv_w = 534, .box_w = 28, .box_h = 36, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 13825, .adv_w = 490, .box_w = 25, .box_h = 36, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 14275, .adv_w = 622, .box_w = 34, .box_h = 38, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 14921, .adv_w = 578, .box_w = 29, .box_h = 36, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 15443, .adv_w = 223, .box_w = 6, .box_h = 36, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 15551, .adv_w = 400, .box_w = 21, .box_h = 37, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 15940, .adv_w = 534, .box_w = 31, .box_h = 36, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 16498, .adv_w = 445, .box_w = 24, .box_h = 36, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 16930, .adv_w = 666, .box_w = 35, .box_h = 36, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 17560, .adv_w = 578, .box_w = 30, .box_h = 36, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 18100, .adv_w = 622, .box_w = 35, .box_h = 38, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 18765, .adv_w = 534, .box_w = 29, .box_h = 36, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 19287, .adv_w = 622, .box_w = 36, .box_h = 40, .ofs_x = 2, .ofs_y = -3}, + {.bitmap_index = 20007, .adv_w = 578, .box_w = 32, .box_h = 36, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 20583, .adv_w = 534, .box_w = 29, .box_h = 38, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 21134, .adv_w = 490, .box_w = 29, .box_h = 36, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 21656, .adv_w = 578, .box_w = 30, .box_h = 37, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 22211, .adv_w = 534, .box_w = 33, .box_h = 36, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 22805, .adv_w = 755, .box_w = 47, .box_h = 36, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 23651, .adv_w = 534, .box_w = 34, .box_h = 36, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 24263, .adv_w = 534, .box_w = 33, .box_h = 36, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 24857, .adv_w = 490, .box_w = 30, .box_h = 36, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 25397, .adv_w = 223, .box_w = 11, .box_h = 46, .ofs_x = 3, .ofs_y = -10}, + {.bitmap_index = 25650, .adv_w = 222, .box_w = 14, .box_h = 38, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 25916, .adv_w = 223, .box_w = 11, .box_h = 46, .ofs_x = 0, .ofs_y = -10}, + {.bitmap_index = 26169, .adv_w = 375, .box_w = 22, .box_h = 20, .ofs_x = 1, .ofs_y = 17}, + {.bitmap_index = 26389, .adv_w = 445, .box_w = 30, .box_h = 4, .ofs_x = -1, .ofs_y = -10}, + {.bitmap_index = 26449, .adv_w = 266, .box_w = 10, .box_h = 7, .ofs_x = 2, .ofs_y = 30}, + {.bitmap_index = 26484, .adv_w = 445, .box_w = 25, .box_h = 28, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 26834, .adv_w = 445, .box_w = 23, .box_h = 37, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 27260, .adv_w = 400, .box_w = 24, .box_h = 28, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 27596, .adv_w = 445, .box_w = 24, .box_h = 37, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 28040, .adv_w = 445, .box_w = 25, .box_h = 28, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 28390, .adv_w = 223, .box_w = 16, .box_h = 37, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 28686, .adv_w = 445, .box_w = 24, .box_h = 38, .ofs_x = 1, .ofs_y = -11}, + {.bitmap_index = 29142, .adv_w = 445, .box_w = 22, .box_h = 36, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 29538, .adv_w = 178, .box_w = 5, .box_h = 36, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 29628, .adv_w = 178, .box_w = 11, .box_h = 47, .ofs_x = -3, .ofs_y = -11}, + {.bitmap_index = 29887, .adv_w = 400, .box_w = 22, .box_h = 36, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 30283, .adv_w = 178, .box_w = 5, .box_h = 36, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 30373, .adv_w = 666, .box_w = 36, .box_h = 27, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 30859, .adv_w = 445, .box_w = 22, .box_h = 27, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 31156, .adv_w = 445, .box_w = 26, .box_h = 28, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 31520, .adv_w = 445, .box_w = 23, .box_h = 37, .ofs_x = 3, .ofs_y = -10}, + {.bitmap_index = 31946, .adv_w = 445, .box_w = 24, .box_h = 37, .ofs_x = 1, .ofs_y = -10}, + {.bitmap_index = 32390, .adv_w = 267, .box_w = 15, .box_h = 27, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 32593, .adv_w = 400, .box_w = 23, .box_h = 28, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 32915, .adv_w = 223, .box_w = 14, .box_h = 37, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 33174, .adv_w = 445, .box_w = 22, .box_h = 27, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 33471, .adv_w = 400, .box_w = 25, .box_h = 26, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 33796, .adv_w = 578, .box_w = 36, .box_h = 26, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 34264, .adv_w = 400, .box_w = 25, .box_h = 26, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 34589, .adv_w = 400, .box_w = 25, .box_h = 37, .ofs_x = 0, .ofs_y = -11}, + {.bitmap_index = 35052, .adv_w = 400, .box_w = 24, .box_h = 26, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 35364, .adv_w = 267, .box_w = 15, .box_h = 48, .ofs_x = 1, .ofs_y = -11}, + {.bitmap_index = 35724, .adv_w = 208, .box_w = 5, .box_h = 48, .ofs_x = 4, .ofs_y = -11}, + {.bitmap_index = 35844, .adv_w = 267, .box_w = 15, .box_h = 48, .ofs_x = 1, .ofs_y = -11}, + {.bitmap_index = 36204, .adv_w = 467, .box_w = 26, .box_h = 10, .ofs_x = 2, .ofs_y = 13}, + {.bitmap_index = 36334, .adv_w = 222, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 36334, .adv_w = 445, .box_w = 27, .box_h = 38, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 36847, .adv_w = 445, .box_w = 25, .box_h = 25, .ofs_x = 1, .ofs_y = 6}, + {.bitmap_index = 37160, .adv_w = 445, .box_w = 28, .box_h = 36, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 37664, .adv_w = 208, .box_w = 5, .box_h = 48, .ofs_x = 4, .ofs_y = -11}, + {.bitmap_index = 37784, .adv_w = 445, .box_w = 24, .box_h = 48, .ofs_x = 2, .ofs_y = -11}, + {.bitmap_index = 38360, .adv_w = 266, .box_w = 15, .box_h = 6, .ofs_x = 1, .ofs_y = 32}, + {.bitmap_index = 38405, .adv_w = 589, .box_w = 37, .box_h = 38, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 39108, .adv_w = 300, .box_w = 19, .box_h = 18, .ofs_x = 0, .ofs_y = 18}, + {.bitmap_index = 39279, .adv_w = 445, .box_w = 22, .box_h = 23, .ofs_x = 3, .ofs_y = 2}, + {.bitmap_index = 39532, .adv_w = 467, .box_w = 25, .box_h = 16, .ofs_x = 2, .ofs_y = 10}, + {.bitmap_index = 39732, .adv_w = 266, .box_w = 15, .box_h = 5, .ofs_x = 1, .ofs_y = 11}, + {.bitmap_index = 39770, .adv_w = 589, .box_w = 37, .box_h = 38, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 40473, .adv_w = 320, .box_w = 14, .box_h = 14, .ofs_x = 3, .ofs_y = 23}, + {.bitmap_index = 40571, .adv_w = 467, .box_w = 25, .box_h = 31, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 40959, .adv_w = 266, .box_w = 16, .box_h = 18, .ofs_x = 0, .ofs_y = 18}, + {.bitmap_index = 41103, .adv_w = 266, .box_w = 16, .box_h = 18, .ofs_x = 0, .ofs_y = 18}, + {.bitmap_index = 41247, .adv_w = 445, .box_w = 22, .box_h = 36, .ofs_x = 3, .ofs_y = -10}, + {.bitmap_index = 41643, .adv_w = 430, .box_w = 28, .box_h = 46, .ofs_x = -1, .ofs_y = -10}, + {.bitmap_index = 42287, .adv_w = 224, .box_w = 6, .box_h = 6, .ofs_x = 4, .ofs_y = 15}, + {.bitmap_index = 42305, .adv_w = 445, .box_w = 22, .box_h = 23, .ofs_x = 3, .ofs_y = 2}, + {.bitmap_index = 42558, .adv_w = 667, .box_w = 39, .box_h = 39, .ofs_x = 2, .ofs_y = -2}, + {.bitmap_index = 43319, .adv_w = 266, .box_w = 10, .box_h = 7, .ofs_x = 5, .ofs_y = 31}, + {.bitmap_index = 43354, .adv_w = 534, .box_w = 35, .box_h = 36, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 43984, .adv_w = 627, .box_w = 40, .box_h = 36, .ofs_x = -3, .ofs_y = 0}, + {.bitmap_index = 44704, .adv_w = 670, .box_w = 40, .box_h = 36, .ofs_x = -3, .ofs_y = 0}, + {.bitmap_index = 45424, .adv_w = 307, .box_w = 17, .box_h = 36, .ofs_x = -3, .ofs_y = 0}, + {.bitmap_index = 45730, .adv_w = 620, .box_w = 40, .box_h = 38, .ofs_x = -3, .ofs_y = -1}, + {.bitmap_index = 46490, .adv_w = 684, .box_w = 46, .box_h = 36, .ofs_x = -3, .ofs_y = 0}, + {.bitmap_index = 47318, .adv_w = 602, .box_w = 39, .box_h = 37, .ofs_x = -3, .ofs_y = 0}, + {.bitmap_index = 48040, .adv_w = 178, .box_w = 19, .box_h = 38, .ofs_x = -4, .ofs_y = 0}, + {.bitmap_index = 48401, .adv_w = 534, .box_w = 35, .box_h = 36, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 49031, .adv_w = 534, .box_w = 28, .box_h = 36, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 49535, .adv_w = 441, .box_w = 23, .box_h = 36, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 49949, .adv_w = 534, .box_w = 35, .box_h = 36, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 50579, .adv_w = 534, .box_w = 28, .box_h = 36, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 51083, .adv_w = 490, .box_w = 30, .box_h = 36, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 51623, .adv_w = 578, .box_w = 29, .box_h = 36, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 52145, .adv_w = 622, .box_w = 35, .box_h = 38, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 52810, .adv_w = 223, .box_w = 6, .box_h = 36, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 52918, .adv_w = 534, .box_w = 31, .box_h = 36, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 53476, .adv_w = 534, .box_w = 34, .box_h = 36, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 54088, .adv_w = 666, .box_w = 35, .box_h = 36, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 54718, .adv_w = 578, .box_w = 30, .box_h = 36, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 55258, .adv_w = 520, .box_w = 28, .box_h = 36, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 55762, .adv_w = 622, .box_w = 35, .box_h = 38, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 56427, .adv_w = 578, .box_w = 29, .box_h = 36, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 56949, .adv_w = 534, .box_w = 29, .box_h = 36, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 57471, .adv_w = 495, .box_w = 26, .box_h = 36, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 57939, .adv_w = 490, .box_w = 29, .box_h = 36, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 58461, .adv_w = 534, .box_w = 33, .box_h = 36, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 59055, .adv_w = 638, .box_w = 36, .box_h = 39, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 59757, .adv_w = 534, .box_w = 34, .box_h = 36, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 60369, .adv_w = 668, .box_w = 36, .box_h = 36, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 61017, .adv_w = 598, .box_w = 34, .box_h = 37, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 61646, .adv_w = 223, .box_w = 15, .box_h = 44, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 61976, .adv_w = 534, .box_w = 33, .box_h = 44, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 62702, .adv_w = 463, .box_w = 27, .box_h = 39, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 63229, .adv_w = 357, .box_w = 20, .box_h = 39, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 63619, .adv_w = 445, .box_w = 22, .box_h = 48, .ofs_x = 3, .ofs_y = -10}, + {.bitmap_index = 64147, .adv_w = 178, .box_w = 10, .box_h = 37, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 64332, .adv_w = 438, .box_w = 22, .box_h = 39, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 64761, .adv_w = 463, .box_w = 27, .box_h = 28, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 65139, .adv_w = 460, .box_w = 24, .box_h = 47, .ofs_x = 3, .ofs_y = -10}, + {.bitmap_index = 65703, .adv_w = 400, .box_w = 25, .box_h = 36, .ofs_x = 0, .ofs_y = -10}, + {.bitmap_index = 66153, .adv_w = 445, .box_w = 26, .box_h = 37, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 66634, .adv_w = 357, .box_w = 20, .box_h = 28, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 66914, .adv_w = 353, .box_w = 21, .box_h = 47, .ofs_x = 1, .ofs_y = -11}, + {.bitmap_index = 67408, .adv_w = 445, .box_w = 22, .box_h = 37, .ofs_x = 3, .ofs_y = -10}, + {.bitmap_index = 67815, .adv_w = 445, .box_w = 24, .box_h = 38, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 68271, .adv_w = 178, .box_w = 5, .box_h = 26, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 68336, .adv_w = 398, .box_w = 22, .box_h = 26, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 68622, .adv_w = 400, .box_w = 25, .box_h = 36, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 69072, .adv_w = 445, .box_w = 22, .box_h = 36, .ofs_x = 3, .ofs_y = -10}, + {.bitmap_index = 69468, .adv_w = 400, .box_w = 25, .box_h = 26, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 69793, .adv_w = 358, .box_w = 20, .box_h = 48, .ofs_x = 2, .ofs_y = -11}, + {.bitmap_index = 70273, .adv_w = 445, .box_w = 26, .box_h = 28, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 70637, .adv_w = 552, .box_w = 33, .box_h = 26, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 71066, .adv_w = 455, .box_w = 24, .box_h = 37, .ofs_x = 3, .ofs_y = -10}, + {.bitmap_index = 71510, .adv_w = 386, .box_w = 22, .box_h = 39, .ofs_x = 2, .ofs_y = -12}, + {.bitmap_index = 71939, .adv_w = 494, .box_w = 29, .box_h = 28, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 72345, .adv_w = 316, .box_w = 18, .box_h = 26, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 72579, .adv_w = 438, .box_w = 22, .box_h = 27, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 72876, .adv_w = 519, .box_w = 30, .box_h = 37, .ofs_x = 1, .ofs_y = -10}, + {.bitmap_index = 73431, .adv_w = 420, .box_w = 26, .box_h = 36, .ofs_x = 0, .ofs_y = -10}, + {.bitmap_index = 73899, .adv_w = 570, .box_w = 31, .box_h = 36, .ofs_x = 2, .ofs_y = -10}, + {.bitmap_index = 74457, .adv_w = 625, .box_w = 35, .box_h = 27, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 74930, .adv_w = 178, .box_w = 15, .box_h = 36, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 75200, .adv_w = 438, .box_w = 22, .box_h = 37, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 75607, .adv_w = 445, .box_w = 26, .box_h = 39, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 76114, .adv_w = 438, .box_w = 22, .box_h = 39, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 76543, .adv_w = 625, .box_w = 35, .box_h = 39, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 77226, .adv_w = 266, .box_w = 19, .box_h = 7, .ofs_x = -1, .ofs_y = 31} +}; + +/*--------------------- + * CHARACTER MAPPING + *--------------------*/ + +static const uint8_t glyph_id_ofs_list_1[] = { + 0, 0, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 0, + 13, 14, 15, 16, 0, 17, 18, 19, + 0, 0, 0, 20, 0, 21 +}; + +static const uint8_t glyph_id_ofs_list_2[] = { + 0, 0, 1, 0, 2, 3, 4, 0, + 5 +}; + +/*Collect the unicode lists and glyph_id offsets*/ +static const lv_font_fmt_txt_cmap_t cmaps[] = +{ + { + .range_start = 32, .range_length = 95, .glyph_id_start = 1, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 160, .range_length = 30, .glyph_id_start = 96, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_1, .list_length = 30, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 900, .range_length = 9, .glyph_id_start = 118, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_2, .list_length = 9, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 910, .range_length = 20, .glyph_id_start = 124, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 931, .range_length = 44, .glyph_id_start = 144, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 1012, .range_length = 1, .glyph_id_start = 188, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + } +}; + + + +/*-------------------- + * ALL CUSTOM DATA + *--------------------*/ + +#if LVGL_VERSION_MAJOR == 8 +/*Store all the custom data of the font*/ +static lv_font_fmt_txt_glyph_cache_t cache; +#endif + +#if LVGL_VERSION_MAJOR >= 8 +static const lv_font_fmt_txt_dsc_t font_dsc = { +#else +static lv_font_fmt_txt_dsc_t font_dsc = { +#endif + .glyph_bitmap = glyph_bitmap, + .glyph_dsc = glyph_dsc, + .cmaps = cmaps, + .kern_dsc = NULL, + .kern_scale = 0, + .cmap_num = 6, + .bpp = 4, + .kern_classes = 0, + .bitmap_format = 0, +#if LVGL_VERSION_MAJOR == 8 + .cache = &cache +#endif + +}; + +extern const lv_font_t lv_font_montserrat_50; + + +/*----------------- + * PUBLIC FONT + *----------------*/ + +/*Initialize a public general font descriptor*/ +#if LVGL_VERSION_MAJOR >= 8 +const lv_font_t lv_font_arial_50 = { +#else +lv_font_t lv_font_arial_50 = { +#endif + .get_glyph_dsc = lv_font_get_glyph_dsc_fmt_txt, /*Function pointer to get glyph's data*/ + .get_glyph_bitmap = lv_font_get_bitmap_fmt_txt, /*Function pointer to get glyph's bitmap*/ + .line_height = 56, /*The maximum line height required by the font*/ + .base_line = 12, /*Baseline measured from the bottom of the line*/ +#if !(LVGL_VERSION_MAJOR == 6 && LVGL_VERSION_MINOR == 0) + .subpx = LV_FONT_SUBPX_NONE, +#endif +#if LV_VERSION_CHECK(7, 4, 0) || LVGL_VERSION_MAJOR >= 8 + .underline_position = -5, + .underline_thickness = 4, +#endif + //.static_bitmap = 0, + .dsc = &font_dsc, /*The custom font data. Will be accessed by `get_glyph_bitmap/dsc` */ +#if LV_VERSION_CHECK(8, 2, 0) || LVGL_VERSION_MAJOR >= 9 + .fallback = &lv_font_montserrat_48, +#endif + .user_data = NULL, +}; + + + +#endif /*#if LV_FONT_ARIAL_50*/ diff --git a/src/fonts/lv_font_arial_58.c b/src/fonts/lv_font_arial_58.c new file mode 100644 index 0000000000..e2670b9c75 --- /dev/null +++ b/src/fonts/lv_font_arial_58.c @@ -0,0 +1,13677 @@ +/******************************************************************************* + * Size: 58 px + * Bpp: 4 + * Opts: --bpp 4 --size 58 --no-compress --stride 1 --align 1 --font Arial Greek Regular.ttf --range 32-127,160-255,880-1023 --format lvgl -o lv_font_arial_58.c + ******************************************************************************/ + +#ifdef __has_include + #if __has_include("lvgl.h") + #ifndef LV_LVGL_H_INCLUDE_SIMPLE + #define LV_LVGL_H_INCLUDE_SIMPLE + #endif + #endif +#endif + +#ifdef LV_LVGL_H_INCLUDE_SIMPLE + #include "lvgl.h" +#else + #include "lvgl/lvgl.h" +#endif + + + +#ifndef LV_FONT_ARIAL_58 +#define LV_FONT_ARIAL_58 1 +#endif + +#if LV_FONT_ARIAL_58 + +/*----------------- + * BITMAPS + *----------------*/ + +/*Store the image of the glyphs*/ +static LV_ATTRIBUTE_LARGE_CONST const uint8_t glyph_bitmap[] = { + /* U+0020 " " */ + + /* U+0021 "!" */ + 0x1f, 0xff, 0xff, 0xf3, 0x1f, 0xff, 0xff, 0xf3, + 0x1f, 0xff, 0xff, 0xf3, 0x1f, 0xff, 0xff, 0xf3, + 0x1f, 0xff, 0xff, 0xf3, 0x1f, 0xff, 0xff, 0xf3, + 0x1f, 0xff, 0xff, 0xf3, 0x1f, 0xff, 0xff, 0xf3, + 0x1f, 0xff, 0xff, 0xf3, 0x1f, 0xff, 0xff, 0xf3, + 0xf, 0xff, 0xff, 0xf2, 0xf, 0xff, 0xff, 0xf1, + 0xd, 0xff, 0xff, 0xf0, 0xc, 0xff, 0xff, 0xf0, + 0xb, 0xff, 0xff, 0xd0, 0xa, 0xff, 0xff, 0xc0, + 0x9, 0xff, 0xff, 0xb0, 0x8, 0xff, 0xff, 0xa0, + 0x7, 0xff, 0xff, 0x90, 0x6, 0xff, 0xff, 0x80, + 0x5, 0xff, 0xff, 0x70, 0x3, 0xff, 0xff, 0x60, + 0x2, 0xff, 0xff, 0x50, 0x1, 0xff, 0xff, 0x40, + 0x0, 0xff, 0xff, 0x30, 0x0, 0xff, 0xff, 0x20, + 0x0, 0xef, 0xff, 0x10, 0x0, 0xdf, 0xff, 0x0, + 0x0, 0xcf, 0xff, 0x0, 0x0, 0xbf, 0xfe, 0x0, + 0x0, 0x9f, 0xfc, 0x0, 0x0, 0x47, 0x75, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xdd, 0xdd, 0xd0, 0xe, 0xff, 0xff, 0xf0, + 0xe, 0xff, 0xff, 0xf0, 0xe, 0xff, 0xff, 0xf0, + 0xe, 0xff, 0xff, 0xf0, 0xe, 0xff, 0xff, 0xf0, + + /* U+0022 "\"" */ + 0x5f, 0xff, 0xff, 0x80, 0x0, 0xef, 0xff, 0xfe, + 0x5f, 0xff, 0xff, 0x80, 0x0, 0xef, 0xff, 0xfe, + 0x5f, 0xff, 0xff, 0x80, 0x0, 0xef, 0xff, 0xfe, + 0x5f, 0xff, 0xff, 0x80, 0x0, 0xef, 0xff, 0xfe, + 0x5f, 0xff, 0xff, 0x80, 0x0, 0xef, 0xff, 0xfe, + 0x5f, 0xff, 0xff, 0x80, 0x0, 0xef, 0xff, 0xfe, + 0x4f, 0xff, 0xff, 0x70, 0x0, 0xef, 0xff, 0xfe, + 0x3f, 0xff, 0xff, 0x60, 0x0, 0xcf, 0xff, 0xfc, + 0xf, 0xff, 0xff, 0x30, 0x0, 0x9f, 0xff, 0xfa, + 0xd, 0xff, 0xff, 0x10, 0x0, 0x7f, 0xff, 0xf7, + 0xa, 0xff, 0xfe, 0x0, 0x0, 0x4f, 0xff, 0xf4, + 0x7, 0xff, 0xfc, 0x0, 0x0, 0x1f, 0xff, 0xf1, + 0x4, 0xff, 0xf9, 0x0, 0x0, 0xe, 0xff, 0xf0, + 0x2, 0xff, 0xf6, 0x0, 0x0, 0xb, 0xff, 0xc0, + 0x0, 0xcd, 0xd3, 0x0, 0x0, 0x7, 0xdd, 0x80, + + /* U+0023 "#" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x33, 0x33, + 0x0, 0x0, 0x0, 0x0, 0x3, 0x33, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x70, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xd0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x14, 0x44, 0x44, 0x44, 0xbf, 0xff, 0xb4, 0x44, + 0x44, 0x44, 0x49, 0xff, 0xfd, 0x44, 0x44, 0x42, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x70, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x14, 0x44, 0x44, 0xaf, 0xff, 0xc4, 0x44, 0x44, + 0x44, 0x49, 0xff, 0xfe, 0x44, 0x44, 0x44, 0x42, + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x9, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x70, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0x44, 0x41, 0x0, 0x0, 0x0, 0x0, + 0x34, 0x44, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0024 "$" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x36, 0xbf, 0xfc, 0x63, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe3, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xff, 0xef, 0xfe, 0xff, 0xff, 0xff, 0xfe, + 0x20, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xfc, 0x50, + 0x7f, 0xf9, 0x7, 0xef, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0x80, 0x0, 0x7f, 0xf9, + 0x0, 0x1d, 0xff, 0xff, 0xf5, 0x0, 0x1, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x2, + 0xff, 0xff, 0xfc, 0x0, 0x6, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x10, 0xa, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x7f, 0xf9, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x50, + 0xc, 0xff, 0xff, 0x40, 0x0, 0x0, 0x7f, 0xf9, + 0x0, 0x0, 0xd, 0xff, 0xff, 0x70, 0xe, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, + 0x5, 0x64, 0x10, 0x0, 0xe, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x7f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xfe, + 0x20, 0x0, 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf5, 0x0, + 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xff, 0xff, 0xd6, 0x8f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x92, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x5a, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xfe, 0xff, 0xff, 0xff, 0xff, + 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xf9, 0x5, 0xcf, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, + 0x0, 0x6, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xf9, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf8, 0x1, 0x48, + 0xb5, 0x0, 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf9, 0xbf, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xf9, 0x9f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x7f, 0xf9, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf8, + 0x7f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x7f, 0xf9, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xf6, 0x3f, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xf2, 0xe, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xe0, 0x8, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x7f, 0xf9, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x70, + 0x1, 0xff, 0xff, 0xff, 0x80, 0x0, 0x7f, 0xf9, + 0x0, 0x7, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xfb, 0x30, 0x7f, 0xf9, 0x4, 0xcf, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xfe, 0xdf, 0xfe, 0xef, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x47, 0xcf, 0xfc, 0x65, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0025 "%" */ + 0x0, 0x0, 0x0, 0x15, 0x67, 0x52, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x78, 0x87, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2a, 0xff, 0xff, 0xff, 0xd6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf8, + 0x21, 0x3a, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x9f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf6, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x1, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0x10, 0x0, 0x0, 0x9, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xf5, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xf7, 0x0, 0x0, 0x2, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0x40, 0x0, 0x0, 0xaf, 0xff, 0xf1, + 0x0, 0x0, 0xa, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf7, 0x10, 0x2a, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x3f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x3, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1a, 0xff, 0xff, + 0xff, 0xe5, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x15, 0x78, 0x63, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x2, 0x57, 0x76, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0x60, 0x0, 0x0, + 0x3, 0xcf, 0xff, 0xff, 0xfe, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf6, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xd0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0x61, + 0x3, 0xbf, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x50, 0x0, 0x0, 0x8f, 0xff, 0xf3, 0x0, 0x0, + 0xa, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xa0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xf5, 0x0, 0x0, + 0x3, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xc0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0x40, 0x0, 0x0, 0x9, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0xa, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0x80, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xf2, 0x0, 0x0, 0xc, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xfe, 0x51, 0x3, 0xbf, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xbf, 0xff, 0xff, + 0xfd, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0x88, 0x86, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x67, 0x86, 0x30, + 0x0, 0x0, 0x0, + + /* U+0026 "&" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x57, + 0x76, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x19, + 0xff, 0xff, 0xff, 0xfe, 0x81, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xeb, + 0xcf, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xd4, 0x0, 0x1, 0x9f, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xfd, 0x10, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xfa, 0x0, 0x4, 0xef, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0x70, 0x8f, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xfe, + 0xff, 0xff, 0xfe, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1a, 0xff, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4e, 0xff, + 0xff, 0xff, 0x9c, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xe3, 0x1, 0xef, 0xff, 0xff, + 0xe1, 0x0, 0x0, 0x9, 0x84, 0x10, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xfb, 0x10, 0x0, 0x3f, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x1f, 0xff, 0xfe, + 0x50, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0x80, 0x0, 0x6f, + 0xff, 0xff, 0x30, 0x0, 0x5, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf5, + 0x0, 0xbf, 0xff, 0xfe, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xff, 0x21, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xdf, 0xff, 0xff, 0xd9, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xef, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x1d, 0xff, 0xff, + 0xff, 0xc6, 0x21, 0x14, 0x9e, 0xff, 0xff, 0xff, + 0xd2, 0xcf, 0xff, 0xff, 0xfc, 0x10, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x10, 0x1d, 0xff, 0xff, 0xff, 0xe1, + 0x0, 0x0, 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x1, 0xdf, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x1, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd4, 0x0, 0x0, 0x0, + 0x1d, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xae, 0xff, 0xff, 0xff, 0xff, 0xb5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x35, 0x67, 0x76, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0x20, 0x0, + + /* U+0027 "'" */ + 0x5f, 0xff, 0xff, 0x75, 0xff, 0xff, 0xf7, 0x5f, + 0xff, 0xff, 0x75, 0xff, 0xff, 0xf7, 0x5f, 0xff, + 0xff, 0x75, 0xff, 0xff, 0xf7, 0x5f, 0xff, 0xff, + 0x74, 0xff, 0xff, 0xf5, 0x1f, 0xff, 0xff, 0x20, + 0xff, 0xff, 0xf0, 0xc, 0xff, 0xfd, 0x0, 0x9f, + 0xff, 0xa0, 0x7, 0xff, 0xf7, 0x0, 0x4f, 0xff, + 0x40, 0x1, 0xdd, 0xd1, 0x0, + + /* U+0028 "(" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xfe, 0x0, + + /* U+0029 ")" */ + 0x9f, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x7, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, + + /* U+002A "*" */ + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x73, 0x0, 0x0, 0x8f, 0xff, 0x0, 0x0, + 0x5, 0x40, 0x2, 0xff, 0xd6, 0x0, 0x6f, 0xfd, + 0x0, 0x39, 0xff, 0xb0, 0x7, 0xff, 0xff, 0xf8, + 0x6f, 0xfb, 0x4c, 0xff, 0xff, 0xf0, 0xc, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x8, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xb4, 0x0, 0x0, 0x47, 0xbe, 0xff, 0xff, + 0xfd, 0xa7, 0x40, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xfb, 0x5f, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf3, 0xb, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xa0, 0x2, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0x10, 0x0, 0x8f, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x5f, 0xf6, 0x0, 0x0, 0xd, 0xfc, + 0x20, 0x0, 0x0, 0x0, 0x2, 0x80, 0x0, 0x0, + 0x2, 0x70, 0x0, 0x0, + + /* U+002B "+" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xaa, 0xaa, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x9c, 0xcc, 0xcc, 0xcc, 0xcc, 0xce, 0xff, 0xff, + 0xdc, 0xcc, 0xcc, 0xcc, 0xcc, 0xc8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+002C "," */ + 0xd, 0xdd, 0xdd, 0xb0, 0xff, 0xff, 0xfd, 0xf, + 0xff, 0xff, 0xd0, 0xff, 0xff, 0xfd, 0xf, 0xff, + 0xff, 0xd0, 0xff, 0xff, 0xfd, 0x0, 0x1, 0xff, + 0xd0, 0x0, 0x3f, 0xfc, 0x0, 0x6, 0xff, 0x90, + 0x0, 0xcf, 0xf5, 0x0, 0x5f, 0xfe, 0x0, 0x6f, + 0xff, 0x60, 0x1e, 0xff, 0xa0, 0x0, 0x6f, 0x70, + 0x0, 0x0, 0x10, 0x0, 0x0, + + /* U+002D "-" */ + 0x2, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x12, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x82, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x82, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf8, + + /* U+002E "." */ + 0xbd, 0xdd, 0xdd, 0xdf, 0xff, 0xff, 0xdf, 0xff, + 0xff, 0xdf, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xdf, + 0xff, 0xff, + + /* U+002F "/" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x78, 0x87, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0030 "0" */ + 0x0, 0x0, 0x0, 0x0, 0x3, 0x8c, 0xef, 0xfe, + 0xc9, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xfc, 0x75, 0x57, + 0xcf, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xfe, 0x40, 0x0, 0x0, 0x3, 0xef, + 0xff, 0xff, 0x40, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xe2, 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0xaf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xfb, 0x0, 0x0, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x10, 0x4, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0x60, 0x8, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xa0, + 0xb, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xd0, 0xe, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xf0, 0x1f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xf2, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf4, + 0x4f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf6, 0x5f, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xf7, 0x6f, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf8, 0x7f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf8, + 0x7f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf9, 0x7f, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf9, 0x7f, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xf9, 0x7f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf8, + 0x6f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf7, 0x5f, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xf6, 0x3f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf5, 0x2f, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf3, + 0xf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xf1, 0xd, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xe0, 0xa, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xb0, 0x6, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x80, + 0x2, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0x30, 0x0, 0xdf, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xfe, 0x0, 0x0, 0x7f, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xf8, 0x0, 0x0, 0xf, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xc4, 0x0, 0x0, 0x3b, 0xff, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xff, 0xec, 0xce, 0xff, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2c, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5b, 0xff, 0xff, 0xff, 0xff, 0xc6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x14, 0x67, 0x76, 0x41, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0031 "1" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x1, 0xcf, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x3e, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0x2, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0x1, 0x9f, 0xff, 0xff, 0xff, 0xbf, 0xff, 0xfb, + 0x5f, 0xff, 0xff, 0xff, 0xe4, 0x6f, 0xff, 0xfb, + 0x9f, 0xff, 0xff, 0xfc, 0x20, 0x6f, 0xff, 0xfb, + 0x9f, 0xff, 0xff, 0x70, 0x0, 0x6f, 0xff, 0xfb, + 0x9f, 0xff, 0x91, 0x0, 0x0, 0x6f, 0xff, 0xfb, + 0x9f, 0x92, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, + + /* U+0032 "2" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x59, 0xce, 0xff, + 0xed, 0xa7, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x18, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xb4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0xa6, 0x54, 0x59, 0xef, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf8, 0x10, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2e, 0xff, 0xff, 0xe1, 0x0, 0x2, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0x70, 0x0, 0x8f, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xfb, 0x0, 0xd, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xf0, 0x0, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x10, + 0x2f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xf2, 0x0, 0x24, + 0x68, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xcf, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, + 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xdf, 0xff, 0xff, + 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xef, 0xff, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1c, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1d, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xfe, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xfd, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0xa, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x42, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf4, + + /* U+0033 "3" */ + 0x0, 0x0, 0x0, 0x0, 0x16, 0xad, 0xef, 0xed, + 0xb7, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x19, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0xd8, 0x54, 0x47, + 0xcf, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x4, 0xef, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, + 0xd0, 0x0, 0x1, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, 0x0, + 0x6, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xf7, 0x0, 0xa, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xf9, 0x0, 0x8, 0xcf, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x24, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x37, + 0xdf, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x36, 0x21, 0x1, 0x5a, 0xff, + 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2d, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfa, 0x0, 0x0, + 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xfb, 0x39, 0xbe, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xfa, 0x4f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf8, + 0x1f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xf5, 0xd, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xf1, 0x7, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xb0, 0x1, 0xff, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0x30, + 0x0, 0x7f, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, + 0x0, 0x3e, 0xff, 0xff, 0xf9, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xfe, 0x71, 0x0, 0x0, 0x3a, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x1, 0xdf, 0xff, + 0xff, 0xff, 0xec, 0xdf, 0xff, 0xff, 0xff, 0xfc, + 0x10, 0x0, 0x0, 0x0, 0x1c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x8d, 0xff, 0xff, 0xff, 0xff, 0xb5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x25, 0x67, 0x75, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0034 "4" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xdf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfe, + 0x3f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf5, 0x2f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xa0, 0x2f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xfe, 0x10, 0x2f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xf4, 0x0, 0x2f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0x90, 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xfd, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf3, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xcf, 0xff, + 0xff, 0xbb, 0xbb, 0xb6, 0x2f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf9, 0x2f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf9, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, + + /* U+0035 "5" */ + 0x0, 0x0, 0x9, 0xee, 0xee, 0xee, 0xee, 0xee, + 0xee, 0xee, 0xee, 0xee, 0xee, 0x10, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x8, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfb, 0x0, + 0x16, 0xad, 0xff, 0xdc, 0x83, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0x82, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0xff, 0xfc, 0x98, 0x9b, 0xef, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0x81, 0x0, 0x0, 0x0, 0x4c, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x4, 0xff, 0xff, 0xfd, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x7f, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x13, 0x58, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xe0, 0x14, 0x57, 0x89, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xfc, 0x5, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x80, + 0x2f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xf4, 0x0, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xfe, 0x0, 0xa, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0x70, 0x0, 0x4f, 0xff, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xc2, 0x0, + 0x0, 0x0, 0x0, 0x2d, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xf7, 0x10, 0x0, + 0x2, 0x8f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xff, 0xdc, 0xce, 0xff, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x18, 0xdf, + 0xff, 0xff, 0xff, 0xfd, 0x71, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x15, 0x67, + 0x76, 0x41, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0036 "6" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x38, 0xbe, 0xff, + 0xed, 0x95, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4d, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd2, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x20, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0x96, 0x44, + 0x6a, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0x91, 0x0, 0x0, 0x0, 0x1c, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0x10, 0x0, 0xd, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x70, + 0x0, 0x5f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xb0, 0x0, 0xbf, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xf0, 0x1, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x87, + 0x54, 0x30, 0x6, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x25, 0x78, 0x75, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xfc, 0x0, 0x0, 0x7e, + 0xff, 0xff, 0xff, 0xfd, 0x70, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xfa, 0x0, 0x4e, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x40, 0x0, 0x0, 0x6f, 0xff, + 0xf9, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x7f, 0xff, 0xf8, 0x5f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x8f, 0xff, 0xfa, 0xff, 0xff, 0xf9, + 0x41, 0x1, 0x38, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0x8f, 0xff, 0xff, 0xff, 0xfc, 0x20, 0x0, 0x0, + 0x0, 0x1b, 0xff, 0xff, 0xfd, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0x60, 0x9f, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0xd0, 0x9f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf2, + 0x8f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xf6, 0x7f, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xf9, 0x6f, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xfb, 0x5f, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfc, 0xf, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xfb, 0xd, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xfa, 0x9, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf7, + 0x5, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xf3, 0x0, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf0, 0x0, 0x9f, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0x80, 0x0, 0x2f, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0x10, + 0x0, 0x8, 0xff, 0xff, 0xfc, 0x10, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xe7, 0x10, 0x0, 0x4, 0xdf, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x1d, 0xff, + 0xff, 0xff, 0xfd, 0xcd, 0xff, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x1, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xe3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xdf, 0xff, 0xff, 0xff, 0xfb, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x46, 0x77, 0x64, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0037 "7" */ + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x2f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x2f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0038 "8" */ + 0x0, 0x0, 0x0, 0x0, 0x4, 0x8c, 0xef, 0xfe, + 0xc9, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xfb, 0x64, 0x46, + 0xaf, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xfd, 0x30, 0x0, 0x0, 0x1, 0xcf, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xd1, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xf9, 0x0, + 0x0, 0x9f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xfe, 0x0, 0x0, 0xbf, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0x0, 0x0, 0xdf, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0x10, 0x0, 0xdf, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x10, + 0x0, 0xbf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xfb, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xe7, 0x20, 0x1, + 0x5c, 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xb1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5d, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x28, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1a, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe5, 0x0, 0x0, 0x0, 0x3, + 0xef, 0xff, 0xff, 0xe9, 0x54, 0x35, 0x9e, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0x10, + 0x5, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xa0, 0xc, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf1, 0x1f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xf6, 0x5f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf9, + 0x7f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xfb, 0x8f, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xfc, 0x7f, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xfc, 0x6f, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xfa, + 0x4f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf8, 0xf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xf4, 0xb, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xf0, 0x3, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x80, + 0x0, 0xaf, 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xff, 0x82, 0x0, 0x0, 0x5, 0xdf, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x2, 0xef, 0xff, + 0xff, 0xff, 0xec, 0xcd, 0xff, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x2c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xe4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfa, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x7c, 0xff, 0xff, 0xff, 0xff, 0xd9, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x14, 0x57, 0x76, 0x52, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0039 "9" */ + 0x0, 0x0, 0x0, 0x0, 0x15, 0xad, 0xef, 0xfd, + 0xa6, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x19, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xfc, 0x75, 0x46, + 0xaf, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xfd, 0x30, 0x0, 0x0, 0x1, 0xaf, + 0xff, 0xff, 0x70, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf2, 0x0, 0x2, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf9, 0x0, + 0x9, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0x10, 0xd, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0x60, 0x1f, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xb0, 0x4f, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf0, + 0x5f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xf2, 0x7f, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xf5, 0x7f, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xf7, 0x5f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf9, + 0x4f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xfa, 0x1f, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xfc, 0xd, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xfc, 0x8, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfc, + 0x1, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xfd, 0x0, 0x9f, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x4e, + 0xff, 0xff, 0xff, 0xfc, 0x0, 0xd, 0xff, 0xff, + 0xff, 0xc6, 0x20, 0x2, 0x5b, 0xff, 0xff, 0xaf, + 0xff, 0xfc, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0x4f, 0xff, 0xfb, + 0x0, 0x0, 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x90, 0x5f, 0xff, 0xfa, 0x0, 0x0, + 0x2, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0x6f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x4, + 0xbf, 0xff, 0xff, 0xff, 0xe8, 0x10, 0x0, 0x7f, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x1, 0x56, + 0x88, 0x63, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xc0, 0x0, 0x2, 0x35, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x80, + 0x9, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0x30, 0x7, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xfd, 0x0, 0x3, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0xdf, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x1, 0xcf, 0xff, 0xff, 0x40, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xf9, 0x20, 0x0, 0x1, 0x7e, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xfe, 0xcc, 0xdf, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xcf, 0xff, 0xff, 0xff, 0xfc, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x46, 0x77, 0x64, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+003A ":" */ + 0xdf, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xdf, 0xff, + 0xff, 0xdf, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xbd, + 0xdd, 0xdd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbd, 0xdd, 0xdd, 0xdf, 0xff, 0xff, 0xdf, 0xff, + 0xff, 0xdf, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xdf, + 0xff, 0xff, + + /* U+003B ";" */ + 0xf, 0xff, 0xff, 0xd0, 0xff, 0xff, 0xfd, 0xf, + 0xff, 0xff, 0xd0, 0xff, 0xff, 0xfd, 0xf, 0xff, + 0xff, 0xd0, 0xdd, 0xdd, 0xdb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xdd, 0xdd, 0xb0, + 0xff, 0xff, 0xfd, 0xf, 0xff, 0xff, 0xd0, 0xff, + 0xff, 0xfd, 0xf, 0xff, 0xff, 0xd0, 0xff, 0xff, + 0xfd, 0x0, 0x1, 0xff, 0xd0, 0x0, 0x3f, 0xfc, + 0x0, 0x6, 0xff, 0x90, 0x0, 0xcf, 0xf5, 0x0, + 0x5f, 0xfe, 0x0, 0x6f, 0xff, 0x60, 0x1e, 0xff, + 0xa0, 0x0, 0x6f, 0x70, 0x0, 0x0, 0x10, 0x0, + 0x0, + + /* U+003C "<" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x47, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6d, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x9f, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xbf, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x17, 0xdf, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x29, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5c, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xa3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x7e, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x71, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0x9f, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xe8, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x17, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xc5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3a, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x92, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xfd, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xfa, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0x92, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xb5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xe7, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x8f, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6d, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4b, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x92, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x29, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xb5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xe7, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x9f, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7d, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4b, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x29, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x14, + + /* U+003D "=" */ + 0x9c, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, + 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xc8, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9c, 0xcc, + 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, + 0xcc, 0xcc, 0xcc, 0xc8, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfa, + + /* U+003E ">" */ + 0x73, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xd6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xe8, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xfb, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xfd, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6d, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x82, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4a, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x18, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xd6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xf9, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xfb, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6d, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x71, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3a, 0xff, 0xff, 0xff, 0xff, 0xff, 0x92, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x17, 0xef, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xbf, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x19, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3a, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6c, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x8e, 0xff, 0xff, + 0xff, 0xff, 0xfa, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xe8, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x17, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xc6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x39, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xa3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5c, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x81, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x8e, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xe8, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xd6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xb4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0x82, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+003F "?" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x14, 0x67, 0x76, + 0x52, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x7d, 0xff, 0xff, 0xff, 0xff, 0xea, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x1c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x1, 0xdf, 0xff, 0xff, 0xff, 0xec, 0xcd, + 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xff, 0x82, 0x0, 0x0, 0x16, 0xef, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xd2, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0xef, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0x80, + 0x5, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xd0, 0xb, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xf2, 0xf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xf4, 0x2f, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf6, + 0x2a, 0xce, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf6, 0x0, 0x0, + 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xbb, 0xbb, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xdd, 0xdd, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0040 "@" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0x46, 0x67, 0x77, 0x65, + 0x31, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x15, 0x9d, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xea, 0x61, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5b, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2c, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xec, 0xbb, 0xbb, 0xce, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xb1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xff, 0xc8, 0x40, 0x0, 0x0, 0x0, 0x0, 0x4, + 0x7c, 0xff, 0xff, 0xff, 0xfe, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xfe, 0x82, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x28, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x19, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xc2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3d, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xbf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0x67, 0x75, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x29, 0xff, 0xff, 0xff, 0xfb, 0x30, 0x0, + 0xc, 0xff, 0xff, 0x40, 0x0, 0x3, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0xef, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0xf, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xf0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x1, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x3f, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf5, 0x0, + 0x0, 0xe, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x1d, 0xff, 0xff, 0xff, 0xfd, 0xce, 0xff, 0xff, + 0xf7, 0x6f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xfa, 0x0, 0x0, 0x5f, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xc4, 0x0, + 0x0, 0x3b, 0xff, 0xff, 0xcf, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xfe, 0x0, 0x0, 0xbf, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0x20, 0x1, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0x40, 0x6, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x60, 0xa, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0x70, 0xe, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x80, 0x1f, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x70, + 0x4f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0x70, 0x6f, 0xff, 0xb0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x50, 0x8f, 0xff, + 0x90, 0x0, 0x0, 0x7, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0x20, 0xaf, 0xff, 0x80, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0x0, 0xaf, 0xff, 0x80, 0x0, + 0x0, 0xc, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xfb, 0x0, 0xbf, + 0xff, 0x80, 0x0, 0x0, 0xe, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xf6, 0x0, 0xbf, 0xff, 0x80, 0x0, 0x0, 0xe, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xf1, 0x0, 0xaf, 0xff, 0x90, + 0x0, 0x0, 0xd, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x90, 0x0, + 0x9f, 0xff, 0xa0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0x20, 0x0, 0x7f, 0xff, 0xd0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xf8, 0x0, 0x0, 0x5f, 0xff, + 0xf0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x3f, 0xff, 0xf3, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0xf, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xe2, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, + 0xfd, 0x0, 0x5, 0xef, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0x95, 0x35, 0x9e, 0xff, + 0xfc, 0xff, 0xff, 0xff, 0xec, 0xef, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc0, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x1c, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x7f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xfe, + 0x60, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, 0xe7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x2, 0x8c, + 0xef, 0xeb, 0x60, 0x0, 0x0, 0x0, 0x6c, 0xef, + 0xfd, 0x95, 0x0, 0x0, 0x0, 0x0, 0x4a, 0xaa, + 0xa7, 0x0, 0x3, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xef, 0xff, 0xf5, 0x0, 0x0, 0x9f, 0xff, + 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x2, 0xff, 0xff, 0xfe, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4e, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xf8, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x19, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xf8, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xef, 0xff, 0xff, + 0xe3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, + 0xff, 0xff, 0xff, 0xfb, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x28, 0xef, + 0xff, 0xff, 0xfc, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xc8, 0x52, 0x0, 0x0, 0x0, 0x0, 0x0, 0x35, + 0x9d, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xdc, 0xcc, + 0xcd, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x94, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x38, 0xbe, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0xb8, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x12, 0x46, 0x67, 0x77, 0x65, 0x43, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0041 "A" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfe, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf8, 0xef, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xf4, 0xaf, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xf0, 0x5f, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xc0, 0xf, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0x70, 0xa, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0x20, 0x4, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xfd, 0x0, 0x0, 0xef, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xf8, 0x0, 0x0, 0x9f, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0x60, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xfa, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, + 0x88, 0x88, 0x9f, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x60, 0x1, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xd0, + 0x7, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf3, 0xd, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xfa, + + /* U+0042 "B" */ + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0xdb, 0x84, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe8, 0x10, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe5, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x47, 0xbf, 0xff, 0xff, 0xff, 0x20, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xcf, 0xff, 0xff, 0xb0, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf1, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf5, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf7, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf9, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf9, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf7, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf4, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf0, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x90, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xdf, 0xff, 0xfe, 0x10, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x12, 0x47, 0xcf, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0x30, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x91, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc6, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd4, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x24, 0x7c, 0xff, 0xff, 0xff, 0xf5, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2b, 0xff, 0xff, 0xff, 0x10, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xa0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf1, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf5, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf8, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf9, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf9, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf7, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf6, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf1, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xd0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1a, 0xff, 0xff, 0xff, 0x50, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0x6a, 0xff, 0xff, 0xff, 0xfc, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe2, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xc2, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc5, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xed, 0xb8, 0x51, 0x0, 0x0, 0x0, 0x0, + + /* U+0043 "C" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x24, 0x67, 0x76, 0x54, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xbe, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x93, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x18, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xa1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1d, 0xff, 0xff, 0xff, 0xff, 0xb8, + 0x64, 0x44, 0x59, 0xdf, 0xff, 0xff, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xff, + 0xfd, 0x60, 0x0, 0x0, 0x0, 0x0, 0x3, 0xcf, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xfc, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0x30, 0x0, 0x2f, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x90, 0x0, 0x8f, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xa0, 0x0, + 0xef, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xa7, + 0x30, 0x0, 0x2, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa7, 0x30, 0x0, 0x0, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xb4, 0x0, 0xbf, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xf6, 0x0, 0x5f, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf1, + 0x0, 0xe, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xb0, 0x0, 0x8, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0x40, 0x0, 0x1, + 0xef, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1a, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xff, 0xfd, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x17, 0xef, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0xff, 0xa7, 0x54, 0x45, 0x7b, 0xff, 0xff, + 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1b, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xb3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x28, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x82, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x35, 0x67, 0x76, 0x54, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0044 "D" */ + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0xdc, 0xa8, 0x41, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xb1, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe3, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x47, 0xbf, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x19, 0xff, 0xff, 0xff, + 0xe0, 0x0, 0x7, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x7f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0x20, 0x7, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xfa, 0x0, 0x7f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xf1, + 0x7, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0x70, 0x7f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xfc, 0x7, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xf1, 0x7f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x47, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf7, + 0x7f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0x97, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xfb, 0x7f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xc7, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfd, 0x7f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xe7, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xfd, 0x7f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xc7, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xfc, 0x7f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xb7, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf8, 0x7f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0x67, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf3, 0x7f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x7, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xa0, 0x7f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xf6, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfe, 0x0, + 0x7f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0x80, 0x7, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xf1, 0x0, 0x7f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xf7, 0x0, 0x7, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xbf, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x24, + 0x8c, 0xff, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x30, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x20, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x71, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xed, 0xb9, + 0x62, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0045 "E" */ + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x6f, 0xff, 0xff, 0xee, 0xee, 0xee, 0xee, 0xee, + 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xe0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + + /* U+0046 "F" */ + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa5, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x5f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xa5, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x95, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf9, 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x5f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0x0, 0x5, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+0047 "G" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x24, 0x67, 0x77, 0x65, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0x7c, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x93, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xff, 0xeb, 0x75, 0x43, 0x45, 0x7a, 0xef, 0xff, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xfb, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3b, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xd3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xef, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0x20, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xf1, 0x0, 0xc, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0x60, 0x3, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xf7, 0x0, 0x9f, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xc7, 0x30, + 0x0, 0xe, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf6, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x6f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf6, 0xef, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6c, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf6, 0xaf, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x67, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xf6, 0x4f, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0x60, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xf6, 0xa, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0x60, 0x4f, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf6, + 0x0, 0xdf, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0x60, 0x5, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf6, 0x0, + 0xb, 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x60, 0x0, 0x1e, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xcf, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xff, 0xa1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3b, 0xff, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, + 0xfa, 0x40, 0x0, 0x0, 0x0, 0x0, 0x26, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xa8, 0x88, + 0x9b, 0xef, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x19, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x15, 0xae, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xea, 0x61, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x35, + 0x77, 0x77, 0x64, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0048 "H" */ + 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, + 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, + 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xf3, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf3, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x5f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, + 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, + 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, + 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xf3, + + /* U+0049 "I" */ + 0xaf, 0xff, 0xfd, 0xaf, 0xff, 0xfd, 0xaf, 0xff, + 0xfd, 0xaf, 0xff, 0xfd, 0xaf, 0xff, 0xfd, 0xaf, + 0xff, 0xfd, 0xaf, 0xff, 0xfd, 0xaf, 0xff, 0xfd, + 0xaf, 0xff, 0xfd, 0xaf, 0xff, 0xfd, 0xaf, 0xff, + 0xfd, 0xaf, 0xff, 0xfd, 0xaf, 0xff, 0xfd, 0xaf, + 0xff, 0xfd, 0xaf, 0xff, 0xfd, 0xaf, 0xff, 0xfd, + 0xaf, 0xff, 0xfd, 0xaf, 0xff, 0xfd, 0xaf, 0xff, + 0xfd, 0xaf, 0xff, 0xfd, 0xaf, 0xff, 0xfd, 0xaf, + 0xff, 0xfd, 0xaf, 0xff, 0xfd, 0xaf, 0xff, 0xfd, + 0xaf, 0xff, 0xfd, 0xaf, 0xff, 0xfd, 0xaf, 0xff, + 0xfd, 0xaf, 0xff, 0xfd, 0xaf, 0xff, 0xfd, 0xaf, + 0xff, 0xfd, 0xaf, 0xff, 0xfd, 0xaf, 0xff, 0xfd, + 0xaf, 0xff, 0xfd, 0xaf, 0xff, 0xfd, 0xaf, 0xff, + 0xfd, 0xaf, 0xff, 0xfd, 0xaf, 0xff, 0xfd, 0xaf, + 0xff, 0xfd, 0xaf, 0xff, 0xfd, 0xaf, 0xff, 0xfd, + 0xaf, 0xff, 0xfd, 0xaf, 0xff, 0xfd, + + /* U+004A "J" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xf7, 0x3, 0x57, 0x97, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf7, + 0x4f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xf6, 0x4f, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf5, + 0x3f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xf4, 0x1f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf1, + 0xd, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xe0, 0x9, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x90, + 0x3, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0x40, 0x0, 0xcf, 0xff, 0xff, + 0xfd, 0x97, 0x79, 0xef, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x4e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7d, + 0xff, 0xff, 0xff, 0xff, 0xb4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x15, 0x67, 0x76, 0x30, + 0x0, 0x0, 0x0, 0x0, + + /* U+004B "K" */ + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, + 0xf5, 0xb, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, + 0xff, 0xf5, 0x0, 0xbf, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, + 0xff, 0xff, 0xf4, 0x0, 0xb, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xef, 0xff, 0xff, 0xf4, 0x0, 0x0, 0xbf, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xef, 0xff, 0xff, 0xf4, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xef, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, + 0xe3, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, + 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, + 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x1, 0xdf, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x1, 0xdf, 0xff, 0xff, 0xe2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, + 0x0, 0x0, 0x1, 0xdf, 0xff, 0xff, 0xd2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xc0, 0x0, 0x1, 0xdf, 0xff, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x1, 0xdf, 0xff, 0xff, + 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xc0, 0x1, 0xdf, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, 0x1, 0xdf, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xc1, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xfd, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xc1, 0xdf, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x3, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0xb, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0xbf, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0x90, 0x0, 0xb, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0x50, + 0x0, 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xfe, 0x10, 0xb, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xfc, 0x0, 0xbf, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xf8, 0xb, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xf3, + + /* U+004C "L" */ + 0xaf, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf4, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x4a, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x4a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + + /* U+004D "M" */ + 0xaf, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xaf, 0xff, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, + 0xaf, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xff, 0xaf, 0xff, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xff, 0xff, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, + 0xaf, 0xff, 0xfe, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0xef, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xcf, 0xff, 0xff, + 0xaf, 0xff, 0xfa, 0x9f, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0x6f, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0x4f, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xfc, 0x5f, 0xff, 0xff, + 0xaf, 0xff, 0xfa, 0xe, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf6, 0x5f, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0x9, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xf1, 0x5f, 0xff, 0xff, + 0xaf, 0xff, 0xfa, 0x3, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xb0, 0x5f, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0x0, + 0xef, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0x60, 0x5f, 0xff, 0xff, + 0xaf, 0xff, 0xfa, 0x0, 0x9f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0x10, 0x5f, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0x0, + 0x3f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfb, 0x0, 0x5f, 0xff, 0xff, + 0xaf, 0xff, 0xfa, 0x0, 0xe, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf5, + 0x0, 0x5f, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0x0, + 0x9, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf0, 0x0, 0x5f, 0xff, 0xff, + 0xaf, 0xff, 0xfa, 0x0, 0x3, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xb0, + 0x0, 0x5f, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0x0, + 0x0, 0xef, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x50, 0x0, 0x5f, 0xff, 0xff, + 0xaf, 0xff, 0xfa, 0x0, 0x0, 0x8f, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0x0, + 0x0, 0x3f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xfa, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xaf, 0xff, 0xfa, 0x0, 0x0, 0xe, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf5, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0x0, + 0x0, 0x8, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xf0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xaf, 0xff, 0xfa, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xf1, 0x0, 0x0, 0x1, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xaf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xf6, 0x0, 0x0, 0x6, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xfb, 0x0, 0x0, 0xc, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xaf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0x10, 0x0, 0x1f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0x50, 0x0, 0x6f, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xaf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xb0, 0x0, 0xcf, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf0, 0x1, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xaf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xf5, 0x7, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfa, 0xc, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xaf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0x2f, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xbf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xaf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xaf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xaf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + + /* U+004E "N" */ + 0x6f, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xf4, 0x6f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xf4, 0x6f, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xf4, 0x6f, 0xff, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf4, 0x6f, + 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf4, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xf4, 0x6f, 0xff, 0xfd, 0xcf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xf4, 0x6f, 0xff, 0xfd, 0x2f, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xfd, 0x7, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xfd, 0x0, + 0xcf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xfd, + 0x0, 0x3f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xf4, 0x6f, 0xff, + 0xfd, 0x0, 0x8, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf4, 0x6f, + 0xff, 0xfd, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf4, + 0x6f, 0xff, 0xfd, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xf4, 0x6f, 0xff, 0xfd, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xf4, 0x6f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xf4, 0x6f, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf4, 0x6f, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf4, + 0x6f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0x60, 0x0, 0x0, 0xff, 0xff, + 0xf4, 0x6f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0xff, + 0xff, 0xf4, 0x6f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x60, + 0x0, 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xf1, 0x0, 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xfb, 0x0, 0xff, 0xff, 0xf4, 0x6f, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0x60, 0xff, 0xff, 0xf4, 0x6f, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xf1, 0xff, 0xff, 0xf4, + 0x6f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xfb, 0xff, 0xff, + 0xf4, 0x6f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xf4, 0x6f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xf4, 0x6f, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xf4, 0x6f, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xf4, + 0x6f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xf4, 0x6f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xf4, + + /* U+004F "O" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x24, 0x67, 0x77, 0x64, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5a, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xfd, 0x96, + 0x54, 0x46, 0x8c, 0xff, 0xff, 0xff, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xff, 0x92, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x7e, 0xff, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xfb, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1a, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xb0, 0x0, 0xe, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x10, 0x3, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xf6, 0x0, 0x8f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xa0, + 0xb, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xfe, 0x0, 0xef, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xf1, 0xf, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0x32, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xf4, 0x3f, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x53, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xf6, 0x4f, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x63, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xf5, 0x2f, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0x51, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xf3, 0xe, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0x10, 0xbf, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xe0, 0x7, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xfa, 0x0, 0x3f, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x60, 0x0, + 0xdf, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xf1, 0x0, 0x8, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0x40, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xa1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x9f, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xf8, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x17, 0xef, 0xff, 0xff, 0xfd, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xff, 0xff, 0xc8, 0x64, 0x44, 0x58, 0xcf, + 0xff, 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7e, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x81, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xae, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x45, 0x67, 0x76, 0x42, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0050 "P" */ + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0xca, 0x85, 0x10, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xb4, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfb, 0x0, 0x8, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x59, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x8f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, + 0xff, 0xff, 0xe0, 0x8, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0x50, 0x8f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xfb, 0x8, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xe0, 0x8f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x8, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf2, 0x8f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x28, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf0, 0x8f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x8, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xc0, + 0x8f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf7, + 0x8, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0x20, 0x8f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xa0, 0x8, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x25, 0x9e, 0xff, 0xff, 0xff, + 0xf2, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x81, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xca, 0x73, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0051 "Q" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x24, 0x67, 0x77, 0x64, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xae, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0xb5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x18, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, + 0xff, 0xd9, 0x65, 0x44, 0x68, 0xbf, 0xff, 0xff, + 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0x82, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x6e, 0xff, 0xff, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xb1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0xef, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xf1, 0x0, 0x3, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf5, 0x0, 0x8, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf9, 0x0, + 0xb, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xfd, 0x0, 0xe, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0x0, 0xf, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x20, 0x2f, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x40, 0x3f, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0x50, 0x4f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0x60, 0x4f, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0x60, 0x3f, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x50, + 0x2f, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0x40, 0xf, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0x30, 0xe, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x10, 0xb, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xfe, 0x0, 0x8, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfa, + 0x0, 0x3, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xf6, 0x0, 0x0, 0xef, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x94, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xe8, 0x10, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x40, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xf7, 0x0, 0x8, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, + 0xc2, 0x5f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x17, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0xb1, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, + 0x81, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xc8, 0x64, + 0x44, 0x68, 0xcf, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf9, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x18, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe7, 0x8, 0xff, 0xff, 0xff, + 0xf8, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xa4, + 0x0, 0x0, 0x4e, 0xff, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x24, + 0x67, 0x77, 0x64, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xaf, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0x9c, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+0052 "R" */ + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0xdb, 0x96, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x50, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xbc, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0x9f, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xef, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xfd, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xfc, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3c, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x24, 0x7c, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe9, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xdc, 0xcc, 0xcc, 0xcd, 0xff, 0xff, 0xff, 0xff, + 0xb2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x1, + 0x6d, 0xff, 0xff, 0xfe, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xe1, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xe1, 0x0, 0x5f, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf9, 0x0, + 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0x40, 0x5f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xff, 0xd0, + + /* U+0053 "S" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x56, + 0x77, 0x65, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x9d, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc8, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xff, 0xfb, 0x87, 0x66, 0x78, 0xbf, + 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xc4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5d, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x8f, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xfc, 0x0, 0x0, 0xaf, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x10, 0x0, 0xcf, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x30, 0x0, 0xcf, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0x50, 0x0, 0xaf, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0x32, 0x10, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xd7, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x73, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x73, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x72, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1a, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd7, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x39, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfa, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xae, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x26, 0xae, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x27, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x49, 0xff, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x19, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xf5, 0x3a, 0xcd, 0xee, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xf8, 0x5f, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf9, 0x3f, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfa, + 0xf, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xf8, 0xc, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xf6, 0x6, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xf2, 0x0, 0xef, 0xff, 0xff, 0xc1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xc0, 0x0, 0x6f, 0xff, 0xff, + 0xfe, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0x50, 0x0, 0xb, 0xff, + 0xff, 0xff, 0xfd, 0x71, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xcf, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x1, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xda, 0x87, 0x78, + 0xac, 0xff, 0xff, 0xff, 0xff, 0xd1, 0x0, 0x0, + 0x0, 0x1c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x7b, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x93, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0x46, 0x77, 0x76, 0x54, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0054 "T" */ + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf2, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf2, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf2, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf2, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0055 "U" */ + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xf4, 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xf4, 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xf4, 0x6f, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf4, 0x6f, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf4, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xf4, 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xf4, 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xf4, 0x6f, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf4, 0x6f, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf4, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xf4, 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xf4, 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xf4, 0x6f, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf4, 0x6f, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf4, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xf4, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xf3, 0x3f, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xf2, 0x2f, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xf0, 0xf, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xe0, 0xd, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xc0, 0xa, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x90, + 0x6, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0x50, 0x1, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0x10, 0x0, 0xcf, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0xe7, 0x10, 0x0, 0x0, 0x0, 0x2, 0x8e, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0xa8, 0x88, 0x9b, 0xef, + 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x18, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x16, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd9, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x24, 0x67, 0x77, 0x65, 0x31, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+0056 "V" */ + 0x8f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x12, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xa0, 0xc, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xf4, 0x0, 0x6f, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xfe, 0x0, 0x0, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0x80, 0x0, 0x9, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0x40, 0x0, 0x0, 0xdf, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfa, 0x0, 0x0, + 0x3f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xf0, 0x0, 0x8, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0x50, 0x0, 0xef, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xfb, 0x0, 0x4f, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xf0, 0x9, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0x50, 0xef, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xfa, 0x3f, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xe8, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+0057 "W" */ + 0x4f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xfd, 0xf, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xf9, 0xc, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xf4, 0x7, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xf0, 0x3, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xc0, 0x0, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xfc, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0x70, 0x0, 0xbf, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xe6, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0x30, 0x0, 0x7f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xa1, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xfe, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0x60, 0xdf, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xfa, 0x0, 0x0, 0xe, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x20, 0x9f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xf6, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xfe, 0x0, 0x5f, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf9, 0x0, 0xf, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xf5, 0x0, 0xc, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xf1, 0x0, 0x8, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xc0, 0x0, + 0x3, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0x80, 0x0, 0x0, 0xef, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0x30, 0x0, 0x0, 0xaf, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0x20, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf6, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xf0, 0x0, 0x0, 0xf, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf9, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf3, + 0x0, 0x0, 0x3f, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xfd, 0x0, 0x0, + 0xc, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xf7, 0x0, 0x0, 0x7f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0x10, 0x0, 0xf, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfc, 0x0, 0x0, + 0xbf, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x40, 0x0, 0x4f, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0x0, 0x0, 0xef, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x80, + 0x0, 0x9f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0x30, 0x3, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xc0, 0x0, 0xdf, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x70, + 0x6, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf0, 0x1, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xa0, 0xa, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xf3, 0x5, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xd0, 0xe, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf6, 0x9, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xf1, 0x2f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf9, 0xd, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf4, 0x5f, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xfc, 0x1f, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf7, 0x9f, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0x5f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf9, 0xcf, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xbf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xfc, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0058 "X" */ + 0x0, 0x7f, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xf6, 0x0, 0x2, 0xff, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf2, 0x0, + 0xdf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xb0, 0x8f, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0x8f, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xf7, 0xd, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xfd, 0x0, 0x4f, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x9f, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0x70, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xf8, 0x0, 0xa, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf4, 0x6, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xe1, + + /* U+0059 "Y" */ + 0x8f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xfd, 0x0, 0xdf, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x30, 0x3, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0x80, 0x0, 0x8, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xf6, 0x0, 0xc, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xe0, 0x6, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0x81, 0xef, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0xaf, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+005A "Z" */ + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x30, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x30, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1d, + 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1d, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, + + /* U+005B "[" */ + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x12, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf1, 0x2f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x12, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf1, 0x2f, 0xff, 0xff, 0x44, 0x44, 0x44, + 0x2, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xf4, 0x44, 0x44, 0x40, 0x2f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x12, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf1, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x12, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + + /* U+005C "\\" */ + 0x78, 0x88, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf0, + + /* U+005D "]" */ + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0x44, 0x44, 0x44, 0xdf, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf4, 0x44, 0x44, + 0x44, 0xdf, 0xff, 0xf4, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, + + /* U+005E "^" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0x7f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xe0, 0xcf, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xf8, 0x5, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x20, 0xe, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xb0, 0x0, 0x8f, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf5, 0x0, + 0x2, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xfe, 0x0, 0x0, 0xb, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x5f, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x60, 0x0, + 0x0, 0xa, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xfd, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf4, + 0x0, 0x0, 0x8f, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xb0, 0x0, 0xe, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0x20, 0x6, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf9, 0x0, 0xdf, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xf1, 0x4f, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x70, + + /* U+005F "_" */ + 0x3b, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, + 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, + 0xb6, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf9, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf9, 0x5f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf9, + + /* U+0060 "`" */ + 0x2e, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0x80, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xe0, + + /* U+0061 "a" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x25, 0x67, 0x77, + 0x65, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xb5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd3, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xdc, 0xcd, + 0xff, 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xf8, 0x20, 0x0, 0x0, 0x3, 0x9f, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0xdf, 0xff, 0xfe, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xfd, 0x0, 0x4, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x0, + 0x9, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x20, 0x9, 0xef, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0x30, 0x0, 0x0, 0x24, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x47, 0xcf, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0x46, 0x8b, 0xef, 0xff, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x15, + 0x9d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x29, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc7, 0x2d, 0xff, 0xff, 0x40, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xdb, 0x86, 0x30, 0x0, + 0xd, 0xff, 0xff, 0x40, 0x8, 0xff, 0xff, 0xff, + 0xd8, 0x40, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0x40, 0x1f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x40, + 0x6f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0x40, 0xaf, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0x40, 0xcf, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0x50, 0xcf, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x50, + 0xaf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0x60, 0x6f, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x2, 0xdf, + 0xff, 0xff, 0xff, 0x60, 0x1f, 0xff, 0xff, 0xfa, + 0x10, 0x0, 0x0, 0x2, 0x9f, 0xff, 0xff, 0xff, + 0xff, 0x70, 0x7, 0xff, 0xff, 0xff, 0xfc, 0x98, + 0x9a, 0xdf, 0xff, 0xff, 0xfa, 0xff, 0xff, 0xa0, + 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x23, 0xff, 0xff, 0xe0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x60, + 0x0, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x29, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x50, 0x0, 0x0, 0x9f, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x3, 0x57, 0x77, + 0x53, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0062 "b" */ + 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x25, 0x77, 0x64, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0x0, 0x6, 0xdf, + 0xff, 0xff, 0xff, 0xc6, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xf0, 0x2c, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x30, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0x2e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x1, 0xff, 0xff, 0xfd, 0xff, 0xff, + 0xfd, 0xcc, 0xef, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0x71, 0x0, 0x0, + 0x3a, 0xff, 0xff, 0xff, 0x10, 0x1, 0xff, 0xff, + 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xfb, 0x0, 0x1f, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, + 0x1, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xb0, 0x1f, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x11, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xf5, 0x1f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x91, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xfc, 0x1f, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xd1, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfe, 0x1f, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xf1, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xfe, 0x1f, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xd1, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xfc, 0x1f, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xa1, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf6, + 0x1f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0x31, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xe0, 0x1f, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf8, + 0x1, 0xff, 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x10, 0x1f, 0xff, + 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0x70, 0x1, 0xff, 0xff, 0xff, 0xff, + 0xe6, 0x0, 0x0, 0x5, 0xdf, 0xff, 0xff, 0xc0, + 0x0, 0x1f, 0xff, 0xfb, 0xef, 0xff, 0xff, 0xdc, + 0xdf, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x1, 0xff, + 0xff, 0xa3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd2, 0x0, 0x0, 0x1f, 0xff, 0xfa, 0x2, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xa0, 0x0, 0x7e, 0xff, + 0xff, 0xff, 0xfa, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0x67, 0x76, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0063 "c" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x14, 0x57, 0x76, + 0x41, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x18, 0xdf, 0xff, 0xff, 0xff, 0xfc, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xe5, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x1, + 0xdf, 0xff, 0xff, 0xff, 0xec, 0xbd, 0xff, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xf8, 0x20, 0x0, 0x1, 0x7f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xd1, 0x0, 0x0, + 0x0, 0x0, 0x3e, 0xff, 0xff, 0xd0, 0x0, 0xe, + 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0x40, 0x6, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf9, 0x0, 0xcf, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xd0, 0xf, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0x74, 0x20, 0x4, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xfd, 0xb9, 0x30, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xf4, 0xc, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0x0, 0x6f, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xb0, 0x0, 0xef, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xf4, 0x0, 0x6, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xef, 0xff, 0xfc, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xfd, 0x51, 0x0, 0x0, 0x18, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0xff, 0xfd, 0xcc, 0xef, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x2d, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x8e, 0xff, 0xff, 0xff, 0xff, 0xb4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x46, 0x77, 0x64, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0064 "d" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x14, 0x67, 0x75, 0x20, 0x0, 0x0, 0xef, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x5, 0xcf, 0xff, + 0xff, 0xff, 0xe7, 0x0, 0xe, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x3d, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x20, 0xef, 0xff, 0xf2, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x2e, + 0xff, 0xff, 0x20, 0x0, 0x4f, 0xff, 0xff, 0xff, + 0xfd, 0xce, 0xff, 0xff, 0xfe, 0xef, 0xff, 0xf2, + 0x0, 0x1e, 0xff, 0xff, 0xfc, 0x40, 0x0, 0x1, + 0x7e, 0xff, 0xff, 0xff, 0xff, 0x20, 0xa, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x1c, 0xff, + 0xff, 0xff, 0xf2, 0x2, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, + 0x20, 0x9f, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf2, 0xf, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x23, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xf2, 0x7f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x2a, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xf2, 0xbf, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0x2c, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf2, 0xef, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0x2e, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xf2, 0xcf, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x2b, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xf2, 0x9f, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0x26, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf2, + 0x2f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x20, 0xdf, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf2, 0x7, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0x20, 0xf, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf2, 0x0, 0x6f, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x1, 0xbf, + 0xff, 0xff, 0xff, 0x20, 0x0, 0xbf, 0xff, 0xff, + 0xe6, 0x0, 0x0, 0x16, 0xef, 0xff, 0xff, 0xff, + 0xf2, 0x0, 0x1, 0xdf, 0xff, 0xff, 0xff, 0xdc, + 0xdf, 0xff, 0xff, 0xfa, 0xff, 0xff, 0x20, 0x0, + 0x2, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf4, 0x8f, 0xff, 0xf2, 0x0, 0x0, 0x1, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xe4, 0x8, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x3a, 0xff, 0xff, + 0xff, 0xff, 0x91, 0x0, 0x8f, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x46, 0x77, 0x63, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0065 "e" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x14, 0x67, 0x77, + 0x52, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6c, 0xff, 0xff, 0xff, 0xff, 0xe9, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5e, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd2, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xec, 0xbd, + 0xff, 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0x82, 0x0, 0x0, 0x5, 0xcf, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xd2, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0xcf, 0xff, 0xfd, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x20, + 0x3, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0x90, 0xa, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xf0, 0xf, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xf4, 0x3f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf8, + 0x7f, 0xff, 0xfd, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x9f, 0xff, 0xfb, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xaf, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9d, 0xb9, 0x73, 0xd, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xf8, 0x6, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf3, + 0x0, 0xef, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xb0, 0x0, 0x6f, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0x30, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xb4, 0x0, 0x0, 0x3, 0xaf, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, + 0xfd, 0xcc, 0xef, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7c, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0x67, 0x77, 0x64, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0066 "f" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x35, 0x77, 0x65, + 0x31, 0x0, 0x0, 0x0, 0x0, 0x7, 0xef, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x1c, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xe7, 0x43, 0x46, + 0x20, 0x0, 0x0, 0xc, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe0, 0x0, 0x8f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x0, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+0067 "g" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x14, 0x67, 0x76, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5c, 0xff, 0xff, 0xff, 0xff, 0x91, + 0x0, 0x3f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x3d, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x3f, + 0xff, 0xf7, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf8, 0x3f, 0xff, 0xf7, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xfd, 0xcd, + 0xff, 0xff, 0xff, 0xbf, 0xff, 0xf7, 0x0, 0x1, + 0xef, 0xff, 0xff, 0xd5, 0x0, 0x0, 0x6, 0xdf, + 0xff, 0xff, 0xff, 0xf7, 0x0, 0xa, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xf7, 0x0, 0x3f, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf7, + 0x0, 0xaf, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf7, 0x1, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf7, 0x5, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xf7, 0x8, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf7, + 0xb, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf7, 0xd, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xf7, 0xe, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xf7, 0xf, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf7, 0xe, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf7, 0xd, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xf7, 0xa, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf7, + 0x7, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf7, 0x3, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xf7, 0x0, 0xdf, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xf7, 0x0, 0x6f, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf7, + 0x0, 0xe, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xef, 0xff, 0xff, 0xf7, 0x0, 0x4, + 0xff, 0xff, 0xfe, 0x50, 0x0, 0x0, 0x0, 0x6e, + 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xfd, 0x85, 0x45, 0x8d, 0xff, 0xff, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0xcf, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xc0, 0xbf, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x5, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xf6, + 0x0, 0xbf, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x4, 0x9c, 0xef, 0xfd, 0xb6, 0x0, 0x0, 0xcf, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xf3, 0x0, 0x53, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xf0, 0x0, 0xff, 0xfe, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xd0, 0x0, 0xdf, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x90, + 0x0, 0xaf, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0x40, 0x0, 0x5f, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xfa, 0x30, 0x0, 0x0, 0x4, 0xbf, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, + 0xdc, 0xcd, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xea, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x35, + 0x67, 0x76, 0x52, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0068 "h" */ + 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x36, 0x77, 0x64, + 0x10, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x0, + 0x3, 0xaf, 0xff, 0xff, 0xff, 0xfd, 0x60, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0x0, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x20, 0x0, 0x1f, 0xff, + 0xff, 0x1c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe1, 0x0, 0x1f, 0xff, 0xff, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xb5, 0x10, 0x1, + 0x5c, 0xff, 0xff, 0xff, 0x40, 0x1f, 0xff, 0xff, + 0xff, 0xd4, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xa0, 0x1f, 0xff, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xe0, 0x1f, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xf1, 0x1f, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xf4, 0x1f, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf5, 0x1f, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf5, 0x1f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, + 0x1f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x1f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf6, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x1f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xf6, 0x1f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf6, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x1f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf6, 0x1f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, + 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x1f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf6, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x1f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xf6, 0x1f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf6, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x1f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf6, 0x1f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, + 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x1f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf6, + + /* U+0069 "i" */ + 0x2f, 0xff, 0xff, 0x2f, 0xff, 0xff, 0x2f, 0xff, + 0xff, 0x2f, 0xff, 0xff, 0x2f, 0xff, 0xff, 0x1e, + 0xee, 0xee, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x2f, + 0xff, 0xff, 0x2f, 0xff, 0xff, 0x2f, 0xff, 0xff, + 0x2f, 0xff, 0xff, 0x2f, 0xff, 0xff, 0x2f, 0xff, + 0xff, 0x2f, 0xff, 0xff, 0x2f, 0xff, 0xff, 0x2f, + 0xff, 0xff, 0x2f, 0xff, 0xff, 0x2f, 0xff, 0xff, + 0x2f, 0xff, 0xff, 0x2f, 0xff, 0xff, 0x2f, 0xff, + 0xff, 0x2f, 0xff, 0xff, 0x2f, 0xff, 0xff, 0x2f, + 0xff, 0xff, 0x2f, 0xff, 0xff, 0x2f, 0xff, 0xff, + 0x2f, 0xff, 0xff, 0x2f, 0xff, 0xff, 0x2f, 0xff, + 0xff, 0x2f, 0xff, 0xff, 0x2f, 0xff, 0xff, 0x2f, + 0xff, 0xff, 0x2f, 0xff, 0xff, 0x2f, 0xff, 0xff, + 0x2f, 0xff, 0xff, 0x2f, 0xff, 0xff, + + /* U+006A "j" */ + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf9, 0x3, 0x20, + 0x17, 0xff, 0xff, 0xf5, 0xc, 0xff, 0xff, 0xff, + 0xff, 0xf1, 0xf, 0xff, 0xff, 0xff, 0xff, 0x90, + 0x3f, 0xff, 0xff, 0xff, 0xfd, 0x10, 0x7f, 0xff, + 0xff, 0xff, 0x91, 0x0, 0x2, 0x57, 0x76, 0x40, + 0x0, 0x0, + + /* U+006B "k" */ + 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xfe, + 0x20, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xe2, 0x0, 0x2f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xfe, 0x20, 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xd1, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xfd, 0x10, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xfc, 0x10, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xc1, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, + 0x6, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0x0, 0x6f, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0x5, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x5f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xfe, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xff, 0xa0, 0xdf, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf9, + 0x0, 0x4f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0x90, 0x0, 0x9, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xc0, 0x0, 0x2f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xf6, 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x20, + 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xc0, 0x2f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xf7, + + /* U+006C "l" */ + 0x2f, 0xff, 0xfe, 0x2f, 0xff, 0xfe, 0x2f, 0xff, + 0xfe, 0x2f, 0xff, 0xfe, 0x2f, 0xff, 0xfe, 0x2f, + 0xff, 0xfe, 0x2f, 0xff, 0xfe, 0x2f, 0xff, 0xfe, + 0x2f, 0xff, 0xfe, 0x2f, 0xff, 0xfe, 0x2f, 0xff, + 0xfe, 0x2f, 0xff, 0xfe, 0x2f, 0xff, 0xfe, 0x2f, + 0xff, 0xfe, 0x2f, 0xff, 0xfe, 0x2f, 0xff, 0xfe, + 0x2f, 0xff, 0xfe, 0x2f, 0xff, 0xfe, 0x2f, 0xff, + 0xfe, 0x2f, 0xff, 0xfe, 0x2f, 0xff, 0xfe, 0x2f, + 0xff, 0xfe, 0x2f, 0xff, 0xfe, 0x2f, 0xff, 0xfe, + 0x2f, 0xff, 0xfe, 0x2f, 0xff, 0xfe, 0x2f, 0xff, + 0xfe, 0x2f, 0xff, 0xfe, 0x2f, 0xff, 0xfe, 0x2f, + 0xff, 0xfe, 0x2f, 0xff, 0xfe, 0x2f, 0xff, 0xfe, + 0x2f, 0xff, 0xfe, 0x2f, 0xff, 0xfe, 0x2f, 0xff, + 0xfe, 0x2f, 0xff, 0xfe, 0x2f, 0xff, 0xfe, 0x2f, + 0xff, 0xfe, 0x2f, 0xff, 0xfe, 0x2f, 0xff, 0xfe, + 0x2f, 0xff, 0xfe, 0x2f, 0xff, 0xfe, + + /* U+006D "m" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x57, 0x77, + 0x52, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x57, + 0x76, 0x41, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf5, + 0x0, 0x5, 0xcf, 0xff, 0xff, 0xff, 0xd6, 0x0, + 0x0, 0x0, 0x6, 0xdf, 0xff, 0xff, 0xff, 0xc4, + 0x0, 0x0, 0x3f, 0xff, 0xf5, 0x1, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x2, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x3f, + 0xff, 0xf5, 0x2e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x0, 0x3e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf9, 0x0, 0x3f, 0xff, 0xf6, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x52, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x30, 0x3f, 0xff, 0xfe, 0xff, 0xff, 0x83, 0x0, + 0x15, 0xdf, 0xff, 0xff, 0xdc, 0xff, 0xfd, 0x62, + 0x0, 0x15, 0xdf, 0xff, 0xff, 0xb0, 0x3f, 0xff, + 0xff, 0xff, 0xb1, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x1d, + 0xff, 0xff, 0xf0, 0x3f, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf4, + 0x3f, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xf6, 0x3f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf7, 0x3f, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf8, 0x3f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf8, 0x3f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xf8, 0x3f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf8, 0x3f, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xf8, 0x3f, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf8, + 0x3f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xf8, 0x3f, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xf8, 0x3f, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf8, 0x3f, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf8, 0x3f, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xf8, 0x3f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf8, 0x3f, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xf8, 0x3f, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf8, + 0x3f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xf8, 0x3f, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xf8, 0x3f, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf8, 0x3f, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf8, 0x3f, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xf8, 0x3f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf8, 0x3f, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xf8, + + /* U+006E "n" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x36, 0x77, + 0x64, 0x10, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf8, + 0x0, 0x3, 0xaf, 0xff, 0xff, 0xff, 0xfc, 0x50, + 0x0, 0x0, 0x1f, 0xff, 0xf8, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0x10, 0x0, 0x1f, + 0xff, 0xf8, 0xc, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd1, 0x0, 0x1f, 0xff, 0xf8, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x0, 0x1f, 0xff, 0xfe, 0xff, 0xff, 0xa5, 0x10, + 0x1, 0x5c, 0xff, 0xff, 0xff, 0x50, 0x1f, 0xff, + 0xff, 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xb0, 0x1f, 0xff, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf0, + 0x1f, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xf1, 0x1f, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xf3, 0x1f, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf4, 0x1f, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xf5, 0x1f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf5, 0x1f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x1f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf6, 0x1f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, + 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x1f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf6, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x1f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xf6, 0x1f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf6, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x1f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf6, 0x1f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, + 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x1f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf6, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x1f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xf6, 0x1f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf6, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x1f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf6, + + /* U+006F "o" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x57, 0x77, + 0x52, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xcf, 0xff, 0xff, 0xff, 0xfe, + 0x93, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x1, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x40, + 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xff, + 0xed, 0xce, 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xff, 0xf8, 0x20, 0x0, + 0x1, 0x6e, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xd2, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xf5, 0x0, 0xb, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xd0, 0x1, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0x40, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf8, 0x8, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xc0, 0xbf, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xd, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xf1, 0xef, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0x2f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf3, + 0xef, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x3d, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xf2, 0xcf, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xb, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xe0, 0x8f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfc, + 0x4, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x80, 0xf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xf3, 0x0, 0x9f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xfd, 0x0, 0x2, 0xff, 0xff, 0xfd, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0x60, 0x0, 0xa, 0xff, 0xff, 0xfd, 0x20, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0x82, 0x0, + 0x0, 0x16, 0xef, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xff, 0xff, 0xfe, 0xcc, 0xdf, + 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7c, + 0xff, 0xff, 0xff, 0xff, 0xd9, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x45, + 0x77, 0x64, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0070 "p" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x57, 0x76, + 0x41, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xf9, 0x0, 0x6, 0xdf, 0xff, 0xff, 0xff, 0xd7, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf9, 0x2, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe4, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xf9, 0x2e, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x1f, 0xff, 0xfa, 0xef, 0xff, 0xfe, 0xa8, 0x9b, + 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x19, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x1f, 0xff, 0xff, 0xff, + 0xe2, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xc0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf4, 0x0, + 0x1f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xfb, 0x0, 0x1f, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0x20, 0x1f, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0x60, 0x1f, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xa0, + 0x1f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xd0, 0x1f, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xe0, 0x1f, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xf0, 0x1f, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf0, + 0x1f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xf0, 0x1f, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xe0, 0x1f, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xd0, 0x1f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xb0, + 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0x70, 0x1f, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0x30, 0x1f, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xfe, 0x0, 0x1f, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf8, 0x0, + 0x1f, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xf1, 0x0, 0x1f, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0x70, 0x0, 0x1f, 0xff, 0xff, 0xff, + 0xfe, 0x50, 0x0, 0x0, 0x5d, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xdc, 0xdf, 0xff, 0xff, 0xff, 0xe2, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0x3, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xa1, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x0, + 0x7, 0xef, 0xff, 0xff, 0xff, 0xa3, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x3, + 0x57, 0x76, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0071 "q" */ + 0x0, 0x0, 0x0, 0x0, 0x1, 0x46, 0x77, 0x63, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5c, 0xff, 0xff, 0xff, 0xfe, 0x70, 0x0, + 0x6f, 0xff, 0xf3, 0x0, 0x0, 0x2, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd3, 0x6, 0xff, 0xff, + 0x30, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf3, 0x6f, 0xff, 0xf3, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xfc, 0xa9, 0xae, 0xff, 0xff, + 0xf8, 0xff, 0xff, 0x30, 0x0, 0xef, 0xff, 0xff, + 0xa2, 0x0, 0x0, 0x4, 0xdf, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x9f, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0x30, 0x2f, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xdf, 0xff, 0xff, 0xf3, 0x9, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0x30, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf3, 0x3f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0x36, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xf3, 0x9f, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0x3b, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xf3, 0xcf, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0x3d, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf3, + 0xcf, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0x3b, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xf3, 0xaf, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0x38, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf3, 0x4f, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0x30, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xf3, 0xb, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x30, 0x4f, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xff, 0xf3, 0x0, 0xdf, 0xff, 0xfd, + 0x10, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0x30, 0x3, 0xff, 0xff, 0xfc, 0x10, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0x8, 0xff, 0xff, 0xfe, 0x61, 0x0, 0x0, 0x5e, + 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, 0xc, 0xff, + 0xff, 0xff, 0xfd, 0xcd, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x5e, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x40, 0xef, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x2, 0x9f, 0xff, 0xff, 0xff, 0xe8, 0x0, 0xe, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x3, + 0x67, 0x76, 0x30, 0x0, 0x0, 0xef, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0x30, + + /* U+0072 "r" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x47, 0x75, 0x10, + 0x0, 0x3f, 0xff, 0xf5, 0x0, 0x4e, 0xff, 0xff, + 0xfc, 0x40, 0x3f, 0xff, 0xf5, 0x6, 0xff, 0xff, + 0xff, 0xff, 0xe0, 0x3f, 0xff, 0xf5, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0x90, 0x3f, 0xff, 0xf6, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0x30, 0x3f, 0xff, 0xfd, + 0xff, 0xff, 0xed, 0xef, 0xfd, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xd4, 0x0, 0x1, 0x76, 0x0, 0x3f, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0073 "s" */ + 0x0, 0x0, 0x0, 0x0, 0x3, 0x56, 0x77, 0x64, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3a, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x93, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1a, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb2, 0x0, 0x0, 0x0, + 0x2, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xff, 0xfc, 0xbb, 0xdf, 0xff, 0xff, 0xff, 0xe1, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xa3, 0x0, 0x0, + 0x0, 0x5d, 0xff, 0xff, 0xf9, 0x0, 0x0, 0xef, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x10, 0x3, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x40, + 0x4, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0x70, 0x5, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x64, + 0x20, 0x0, 0x3, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xb5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xff, 0xfb, 0x62, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd9, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb6, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x6, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x59, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x6a, 0xef, 0xff, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xaf, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xf9, 0x3, 0x57, 0xab, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfb, 0x1f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xfb, 0xd, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf9, + 0x7, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xf6, 0x1, 0xff, 0xff, + 0xfd, 0x20, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xf1, 0x0, 0x8f, 0xff, 0xff, 0xf8, 0x20, + 0x0, 0x0, 0x16, 0xef, 0xff, 0xff, 0x70, 0x0, + 0xc, 0xff, 0xff, 0xff, 0xfe, 0xcb, 0xcd, 0xff, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x17, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xd7, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x46, 0x77, 0x76, 0x41, 0x0, 0x0, 0x0, 0x0, + + /* U+0074 "t" */ + 0x0, 0x0, 0x0, 0x0, 0x4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xcc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x9f, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3e, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xd6, 0x45, 0x60, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x1, 0xdf, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x1a, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x14, 0x67, 0x76, 0x30, + + /* U+0075 "u" */ + 0x2f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xf3, 0x2f, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xf3, 0x2f, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf3, 0x2f, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xf3, 0x2f, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xf3, 0x2f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xf3, 0x2f, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xf3, 0x2f, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf3, + 0x2f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xf3, 0x2f, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xf3, 0x2f, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf3, 0x2f, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xf3, 0x2f, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xf3, 0x2f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xf3, 0x2f, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xf3, 0x2f, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf3, + 0x2f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xf3, 0x2f, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xf3, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf3, 0x2f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xf3, 0x1f, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xf3, 0xf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf3, 0xe, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xf3, 0xb, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf3, + 0x7, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x1c, 0xff, 0xff, 0xff, 0xf3, 0x2, 0xff, 0xff, + 0xff, 0xd6, 0x10, 0x0, 0x38, 0xff, 0xff, 0xdf, + 0xff, 0xf3, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x6f, 0xff, 0xf3, 0x0, + 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xc0, 0x5f, 0xff, 0xf3, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x5f, 0xff, + 0xf3, 0x0, 0x0, 0x3, 0xaf, 0xff, 0xff, 0xff, + 0xfa, 0x30, 0x0, 0x5f, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x36, 0x77, 0x64, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+0076 "v" */ + 0x1f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x20, 0xbf, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xc0, 0x5, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xf6, 0x0, 0xe, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0x0, 0x0, 0x8f, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x90, + 0x0, 0x2, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xf3, 0x0, 0x0, + 0xc, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf5, 0x0, 0x0, 0x3, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x9f, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x10, 0x0, + 0xe, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xf6, 0x0, 0x5, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xc0, 0x0, 0xaf, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0x10, 0x1f, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xf6, 0x6, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xc0, + 0xbf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x2f, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xfb, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+0077 "w" */ + 0x9f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xf6, 0x4f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf1, 0xe, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xc0, 0xa, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0x70, 0x5, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0x20, 0x0, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xfd, 0x0, 0x0, 0xbf, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xf8, 0x0, 0x0, 0x6f, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xcf, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf3, 0x0, + 0x0, 0x1f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x7b, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xe0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x2, 0xff, 0xff, 0x38, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x8, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x6, 0xff, 0xff, 0x4, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x8, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xb0, 0x0, 0x0, 0xa, 0xff, + 0xfb, 0x1, 0xff, 0xff, 0xa0, 0x0, 0x0, 0xd, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xf0, 0x0, 0x0, 0xe, 0xff, 0xf6, 0x0, 0xdf, + 0xff, 0xe0, 0x0, 0x0, 0x1f, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf4, 0x0, 0x0, + 0x3f, 0xff, 0xf2, 0x0, 0x8f, 0xff, 0xf3, 0x0, + 0x0, 0x6f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xf8, 0x0, 0x0, 0x7f, 0xff, 0xe0, + 0x0, 0x4f, 0xff, 0xf7, 0x0, 0x0, 0xbf, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xfd, + 0x0, 0x0, 0xcf, 0xff, 0xa0, 0x0, 0xf, 0xff, + 0xfb, 0x0, 0x0, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0x10, 0x0, 0xff, + 0xff, 0x60, 0x0, 0xc, 0xff, 0xff, 0x0, 0x5, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0x60, 0x4, 0xff, 0xff, 0x10, 0x0, + 0x7, 0xff, 0xff, 0x30, 0x9, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xa0, + 0x9, 0xff, 0xfd, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x70, 0xe, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xe0, 0xd, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xb0, 0x3f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xf3, 0x1f, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf0, 0x8f, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf7, 0x5f, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf4, + 0xcf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xfc, 0x9f, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xfa, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xdf, 0xff, 0x80, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + + /* U+0078 "x" */ + 0x6, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xf6, 0x0, 0xb, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf8, 0x0, 0xa, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xf3, 0x5, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0xc1, 0xef, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xef, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0x8f, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0x90, 0xaf, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xe0, 0x1, 0xef, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf4, 0x0, + 0x5, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xf9, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0x20, 0x0, + 0xc, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xfc, 0x0, 0x8, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xf8, 0x3, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xf3, + + /* U+0079 "y" */ + 0xd, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0x40, 0x8f, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xe0, 0x2, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xf8, 0x0, 0xb, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0x20, 0x0, 0x5f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf6, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0x10, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x8, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x4f, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x50, 0x0, + 0x9, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xfa, 0x0, 0x0, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xf0, 0x0, 0x5f, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0x50, 0xa, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xfb, 0x0, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf0, + 0x5f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x49, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf9, 0xdf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xef, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xca, 0x88, 0xae, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfa, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x15, 0x77, 0x51, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+007A "z" */ + 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x0, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd0, 0xb, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x1, 0x11, + 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x3f, + 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1d, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xfd, 0x34, 0x55, 0x66, + 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x65, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xcd, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcd, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, + + /* U+007B "{" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x36, 0x77, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x9f, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xd5, 0x10, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x4a, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xfe, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xb1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4d, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xef, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xc4, 0x10, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x1d, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xaf, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x46, 0x77, 0x80, + + /* U+007C "|" */ + 0xaf, 0xff, 0xca, 0xff, 0xfc, 0xaf, 0xff, 0xca, + 0xff, 0xfc, 0xaf, 0xff, 0xca, 0xff, 0xfc, 0xaf, + 0xff, 0xca, 0xff, 0xfc, 0xaf, 0xff, 0xca, 0xff, + 0xfc, 0xaf, 0xff, 0xca, 0xff, 0xfc, 0xaf, 0xff, + 0xca, 0xff, 0xfc, 0xaf, 0xff, 0xca, 0xff, 0xfc, + 0xaf, 0xff, 0xca, 0xff, 0xfc, 0xaf, 0xff, 0xca, + 0xff, 0xfc, 0xaf, 0xff, 0xca, 0xff, 0xfc, 0xaf, + 0xff, 0xca, 0xff, 0xfc, 0xaf, 0xff, 0xca, 0xff, + 0xfc, 0xaf, 0xff, 0xca, 0xff, 0xfc, 0xaf, 0xff, + 0xca, 0xff, 0xfc, 0xaf, 0xff, 0xca, 0xff, 0xfc, + 0xaf, 0xff, 0xca, 0xff, 0xfc, 0xaf, 0xff, 0xca, + 0xff, 0xfc, 0xaf, 0xff, 0xca, 0xff, 0xfc, 0xaf, + 0xff, 0xca, 0xff, 0xfc, 0xaf, 0xff, 0xca, 0xff, + 0xfc, 0xaf, 0xff, 0xca, 0xff, 0xfc, 0xaf, 0xff, + 0xca, 0xff, 0xfc, 0xaf, 0xff, 0xca, 0xff, 0xfc, + 0xaf, 0xff, 0xca, 0xff, 0xfc, 0xaf, 0xff, 0xca, + 0xff, 0xfc, 0xaf, 0xff, 0xca, 0xff, 0xfc, 0xaf, + 0xff, 0xc0, + + /* U+007D "}" */ + 0x57, 0x76, 0x52, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xfd, 0x40, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x39, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xd5, 0x10, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x3d, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xfd, 0x90, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0x91, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x3, 0x9f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xc4, 0x0, + 0x0, 0x0, 0x0, 0x5, 0x87, 0x64, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+007E "~" */ + 0x0, 0x0, 0x0, 0x35, 0x64, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, + 0x3, 0xbf, 0xff, 0xff, 0xfe, 0xa4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x87, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xe8, 0x20, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xf7, 0xc, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x40, 0x0, + 0x0, 0x4, 0xdf, 0xf7, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xa7, 0x69, + 0xdf, 0xff, 0xf7, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf7, 0x8f, 0xff, 0xd6, 0x20, 0x13, 0x7d, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf5, 0x8f, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x3a, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, + 0x8e, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x18, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xb3, 0x0, 0x62, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0x9c, 0xef, 0xec, 0x83, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00A0 " " */ + + /* U+00A3 "£" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x45, + 0x77, 0x64, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6c, 0xff, 0xff, + 0xff, 0xff, 0xd7, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0xfd, 0xcc, 0xef, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xff, 0x81, 0x0, 0x0, 0x29, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xfe, 0x30, 0x0, 0x0, 0x0, 0x4, + 0xef, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x8f, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf8, 0x0, 0x0, 0xa, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xdb, + 0x96, 0x30, 0x0, 0x0, 0xbf, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x23, + 0x33, 0x8f, 0xff, 0xff, 0x63, 0x33, 0x33, 0x33, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0x70, 0x13, 0x21, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xfc, 0xff, 0xff, 0xff, 0xda, 0x73, 0x0, + 0x0, 0x0, 0x0, 0x4b, 0x40, 0xc, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, + 0x87, 0x7a, 0xef, 0xf9, 0x0, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe0, 0x6, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x50, 0xf, 0xff, 0xfd, 0x85, + 0x21, 0x1, 0x36, 0xae, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf9, 0x0, 0x9f, 0xa3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0x7b, 0xff, 0xff, 0xff, + 0xfe, 0x93, 0x0, 0x2, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x36, 0x77, 0x52, + 0x0, 0x0, + + /* U+00A4 "¤" */ + 0x0, 0x1a, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x93, 0x0, 0x0, 0x1d, + 0xfc, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xe3, 0x0, 0xc, 0xff, 0xfc, + 0x10, 0x1, 0x6a, 0xef, 0xfe, 0xb8, 0x20, 0x0, + 0xaf, 0xff, 0xe2, 0x8, 0xff, 0xff, 0xfc, 0x29, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xb2, 0x9f, 0xff, + 0xff, 0xc0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe2, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd1, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xff, 0xff, 0xdb, 0xbd, 0xff, + 0xff, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xf9, 0x20, 0x0, 0x1, 0x8f, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x5f, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf9, 0x0, 0x0, + 0x9, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xd0, 0x0, 0x0, 0xcf, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0x0, 0x0, 0xd, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xf1, 0x0, 0x0, 0xdf, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0x10, 0x0, 0xb, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf0, 0x0, + 0x0, 0x9f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xfd, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0x90, 0x0, 0x0, 0xe, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x3, 0xef, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x92, + 0x0, 0x0, 0x18, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xfd, 0xbb, + 0xdf, 0xff, 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x10, 0x0, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x20, 0x8f, 0xff, 0xff, 0xc1, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x29, 0xff, + 0xff, 0xfc, 0x0, 0xcf, 0xff, 0xc0, 0x0, 0x16, + 0xbe, 0xff, 0xeb, 0x82, 0x0, 0x9, 0xff, 0xfe, + 0x20, 0x1, 0xdf, 0xc1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0x30, 0x0, + 0x1, 0xa1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0x30, 0x0, + + /* U+00A5 "¥" */ + 0xbf, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xfe, + 0x2, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0x50, 0x9, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xd0, 0x0, 0x1f, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0xef, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0x80, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0x10, 0x0, 0x0, + 0xef, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xf9, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf2, 0x0, + 0xe, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xa0, + 0x8, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0x20, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf9, 0x7f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xfe, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x33, 0x33, 0x33, 0x33, 0x3c, + 0xff, 0xff, 0xff, 0xff, 0xe4, 0x33, 0x33, 0x33, + 0x33, 0x10, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, + 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00A6 "¦" */ + 0xaf, 0xff, 0xca, 0xff, 0xfc, 0xaf, 0xff, 0xca, + 0xff, 0xfc, 0xaf, 0xff, 0xca, 0xff, 0xfc, 0xaf, + 0xff, 0xca, 0xff, 0xfc, 0xaf, 0xff, 0xca, 0xff, + 0xfc, 0xaf, 0xff, 0xca, 0xff, 0xfc, 0xaf, 0xff, + 0xca, 0xff, 0xfc, 0xaf, 0xff, 0xca, 0xff, 0xfc, + 0xaf, 0xff, 0xca, 0xff, 0xfc, 0xaf, 0xff, 0xca, + 0xff, 0xfc, 0xaf, 0xff, 0xca, 0xff, 0xfc, 0x58, + 0x88, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x69, 0x99, 0x7a, 0xff, 0xfc, 0xaf, 0xff, 0xca, + 0xff, 0xfc, 0xaf, 0xff, 0xca, 0xff, 0xfc, 0xaf, + 0xff, 0xca, 0xff, 0xfc, 0xaf, 0xff, 0xca, 0xff, + 0xfc, 0xaf, 0xff, 0xca, 0xff, 0xfc, 0xaf, 0xff, + 0xca, 0xff, 0xfc, 0xaf, 0xff, 0xca, 0xff, 0xfc, + 0xaf, 0xff, 0xca, 0xff, 0xfc, 0xaf, 0xff, 0xca, + 0xff, 0xfc, 0xaf, 0xff, 0xca, 0xff, 0xfc, 0xaf, + 0xff, 0xc0, + + /* U+00A7 "§" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x25, 0x67, 0x65, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7e, 0xff, 0xff, 0xff, 0xff, 0xb5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3e, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xdb, 0xce, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x92, 0x0, 0x0, 0x3c, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x9, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x90, 0x0, + 0x0, 0xc, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xe0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0xc, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x1, 0xec, 0xb9, + 0x81, 0x0, 0x0, 0x9, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xfd, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xc2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5d, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xfd, 0xff, 0xff, 0xff, 0xfd, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfc, 0x20, 0x8f, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xb0, 0x0, 0x4, 0xef, 0xff, + 0xff, 0xff, 0xe4, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x4f, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x3d, 0xff, 0xff, 0xff, 0xfb, + 0x10, 0x0, 0x7f, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xd1, 0x0, + 0x9f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xdf, 0xff, 0xff, 0xfd, 0x0, 0x8f, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0x80, 0x6f, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xf1, 0x2f, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf5, + 0xc, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf9, 0x4, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xfa, 0x0, 0x9f, 0xff, 0xff, + 0xfb, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xfa, 0x0, 0xa, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf9, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xd4, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf5, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xff, 0xa1, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x2c, + 0xff, 0xff, 0xff, 0xfe, 0x50, 0x0, 0x1c, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xfb, 0x14, 0xef, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1b, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5e, 0xff, 0xff, 0xff, 0xc1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xbf, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x25, 0x73, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xf9, 0x0, 0x0, 0xaf, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xfb, 0x0, 0x0, 0x9f, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xfb, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfa, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x1c, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xff, 0xe6, 0x10, 0x0, 0x16, 0xef, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0xfe, 0xde, 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4b, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0x56, 0x76, 0x53, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00A8 "¨" */ + 0x3d, 0xdd, 0xdd, 0x0, 0x0, 0x9, 0xdd, 0xdd, + 0x84, 0xff, 0xff, 0xf0, 0x0, 0x0, 0xbf, 0xff, + 0xf9, 0x4f, 0xff, 0xff, 0x0, 0x0, 0xb, 0xff, + 0xff, 0x94, 0xff, 0xff, 0xf0, 0x0, 0x0, 0xbf, + 0xff, 0xf9, 0x4f, 0xff, 0xff, 0x0, 0x0, 0xb, + 0xff, 0xff, 0x94, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0xbf, 0xff, 0xf9, + + /* U+00A9 "©" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x69, 0xce, 0xff, 0xfe, 0xc9, 0x62, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x18, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5e, 0xff, 0xff, + 0xff, 0xfc, 0xa9, 0x9a, 0xbe, 0xff, 0xff, 0xff, + 0xfd, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xe8, 0x30, 0x0, + 0x0, 0x0, 0x1, 0x5b, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xcf, + 0xff, 0xfe, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0x9f, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2c, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xe3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x59, 0xde, 0xff, 0xda, 0x50, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0x20, 0x0, 0x0, + 0xe, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x7, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xe6, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xfb, 0x0, 0x0, 0x7, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xf5, 0x0, 0x0, 0xef, 0xfe, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xd7, 0x43, 0x47, 0xcf, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, 0x0, + 0x6f, 0xff, 0x60, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x30, 0xc, 0xff, 0xe0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xc0, 0x0, 0x0, 0x3, + 0xff, 0xf9, 0x2, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x20, 0x0, 0x0, 0xd, 0xff, 0xe0, + 0x6f, 0xff, 0x30, 0x0, 0x0, 0x1f, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x95, 0x10, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0x29, 0xff, 0xf0, + 0x0, 0x0, 0x5, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xf6, 0xcf, 0xfc, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0x8d, 0xff, 0xa0, 0x0, 0x0, 0xa, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xfa, 0xef, 0xf9, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xaf, 0xff, 0x80, 0x0, 0x0, + 0xc, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xfb, 0xff, 0xf9, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xbe, 0xff, + 0xa0, 0x0, 0x0, 0xa, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xfa, 0xcf, 0xfc, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x8a, 0xff, 0xf0, 0x0, 0x0, 0x4, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0x95, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf5, 0x7f, + 0xff, 0x30, 0x0, 0x0, 0xf, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x23, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0x40, 0x0, 0x0, 0xc, + 0xff, 0xe0, 0xd, 0xff, 0xe0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xc0, 0x0, 0x0, 0x2, 0xff, 0xf9, 0x0, + 0x8f, 0xff, 0x60, 0x0, 0x0, 0x8, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x2, 0xcf, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x30, 0x1, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xd8, 0x65, + 0x7b, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xc0, 0x0, 0x9, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf4, 0x0, + 0x0, 0x1e, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xc3, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x1, 0x6a, 0xde, + 0xfe, 0xc9, 0x40, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xe3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xdf, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1b, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xcf, + 0xff, 0xfe, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x8f, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xe8, 0x30, 0x0, 0x0, 0x0, 0x0, 0x4a, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xfc, + 0xa9, 0x9a, 0xbd, 0xff, 0xff, 0xff, 0xfd, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x8e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x7a, + 0xce, 0xff, 0xfe, 0xc9, 0x62, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00AA "ª" */ + 0x0, 0x0, 0x1, 0x7c, 0xef, 0xec, 0x61, 0x0, + 0x5f, 0xff, 0xc0, 0x0, 0x6, 0xef, 0xff, 0xff, + 0xff, 0xe4, 0x9, 0xff, 0xf7, 0x0, 0x7, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf4, 0xdf, 0xff, 0x20, + 0x4, 0xff, 0xff, 0xe7, 0x32, 0x6d, 0xff, 0xff, + 0xff, 0xe0, 0x0, 0xef, 0xff, 0xe1, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xfa, 0x0, 0x5f, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x70, 0xa, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xf3, 0x0, 0xdf, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0x0, 0xf, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xd0, 0x1, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x1, 0xff, 0xfa, + 0x0, 0x1f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0x70, 0x0, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xf9, 0x0, 0xf, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, + 0x0, 0xcf, 0xff, 0x80, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0x0, 0x9, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf3, 0x0, 0x3f, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x70, + 0x0, 0xcf, 0xff, 0xd1, 0x0, 0x0, 0x2e, 0xff, + 0xff, 0xfb, 0x0, 0x3, 0xff, 0xff, 0xe6, 0x33, + 0x7e, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf4, 0xcf, 0xff, 0x50, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x6, + 0xff, 0xfa, 0x0, 0x0, 0x1, 0x7c, 0xef, 0xec, + 0x71, 0x0, 0x3, 0x33, 0x30, + + /* U+00AB "«" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xf4, 0x0, 0x0, 0x3, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xb0, 0x0, 0x0, + 0xd, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x8f, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf9, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xe1, 0x0, 0x0, 0xd, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x9f, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xfd, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xff, 0xf4, 0x0, 0x0, 0xe, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x9f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0x20, 0x0, 0x4, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xf1, 0x0, 0x0, 0xaf, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0xaf, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xf9, 0x0, + 0x0, 0x1e, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x4, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x9f, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xf4, 0x0, + 0x0, 0xd, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xfd, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x8f, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xe0, 0x0, + 0x0, 0xd, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xf8, 0x0, 0x0, 0x3, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x8f, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xa0, 0x0, + 0x0, 0xc, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xf3, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xd0, + + /* U+00AC "¬" */ + 0x9c, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, + 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xc8, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x18, 0x88, 0x85, + + /* U+00AD "­" */ + 0x2, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x12, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x82, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x82, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf8, + + /* U+00AE "®" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x69, 0xce, 0xff, 0xfe, 0xc9, 0x62, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x18, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5e, 0xff, 0xff, + 0xff, 0xfc, 0xa9, 0x9a, 0xbe, 0xff, 0xff, 0xff, + 0xfd, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xe8, 0x30, 0x0, + 0x0, 0x0, 0x1, 0x5b, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xcf, + 0xff, 0xfe, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0x9f, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2c, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xe3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0x20, 0x0, 0x0, + 0xe, 0xff, 0xf5, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xed, 0xa7, 0x10, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xfb, 0x0, 0x0, 0x7, 0xff, 0xf9, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xf5, 0x0, 0x0, 0xef, 0xfe, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xc0, 0x0, + 0x6f, 0xff, 0x60, 0x0, 0x0, 0xf, 0xff, 0xc2, + 0x22, 0x22, 0x35, 0x8e, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0x30, 0xc, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x1d, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xf9, 0x2, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xe0, + 0x6f, 0xff, 0x30, 0x0, 0x0, 0x0, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0x29, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xf6, 0xcf, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x1d, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0x8d, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xb0, 0x0, 0x0, 0x3, 0x7e, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xfa, 0xef, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xaf, 0xff, 0x80, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xfb, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x72, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xbe, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xc3, 0x33, + 0x6c, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xfa, 0xcf, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xfb, 0x0, 0x0, 0x9, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x8a, 0xff, 0xf0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xb0, 0x0, 0x0, 0xb, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xf5, 0x7f, + 0xff, 0x30, 0x0, 0x0, 0x0, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0x23, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xe0, 0xd, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x2, 0xff, 0xf9, 0x0, + 0x8f, 0xff, 0x60, 0x0, 0x0, 0xf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0x30, 0x1, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xc0, 0x0, 0x9, 0xff, 0xf9, 0x0, 0x0, + 0xf, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xf4, 0x0, 0x0, 0xc, 0xff, 0xf4, 0x0, + 0x0, 0x1e, 0xff, 0xf5, 0x0, 0x0, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xd0, + 0x0, 0x8, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xf3, 0x0, 0x3, 0x44, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x44, 0x44, 0x10, 0x6, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xe3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xdf, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1b, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xcf, + 0xff, 0xfe, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x8f, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xe8, 0x30, 0x0, 0x0, 0x0, 0x0, 0x4a, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xfc, + 0xa9, 0x9a, 0xbd, 0xff, 0xff, 0xff, 0xfd, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x8e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x7a, + 0xce, 0xff, 0xfe, 0xc9, 0x62, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00B0 "°" */ + 0x0, 0x0, 0x5, 0xbe, 0xfe, 0xb6, 0x0, 0x0, + 0x0, 0x0, 0x2c, 0xff, 0xff, 0xff, 0xfe, 0x30, + 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x40, 0x0, 0xd, 0xff, 0xf9, 0x31, 0x38, 0xff, + 0xff, 0x20, 0x7, 0xff, 0xf4, 0x0, 0x0, 0x2, + 0xef, 0xfa, 0x0, 0xdf, 0xf8, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xf1, 0x1f, 0xff, 0x10, 0x0, 0x0, + 0x0, 0xd, 0xff, 0x43, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xf6, 0x3f, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0x61, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xf4, 0xd, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0x0, 0x7f, 0xff, + 0x50, 0x0, 0x0, 0x3e, 0xff, 0xa0, 0x0, 0xdf, + 0xff, 0x94, 0x23, 0x8f, 0xff, 0xf2, 0x0, 0x2, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x1, 0xcf, 0xff, 0xff, 0xff, 0xe3, 0x0, 0x0, + 0x0, 0x0, 0x5b, 0xef, 0xeb, 0x60, 0x0, 0x0, + + /* U+00B1 "±" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9c, 0xcc, 0xcc, 0xcc, 0xcc, 0xce, + 0xff, 0xff, 0xdc, 0xcc, 0xcc, 0xcc, 0xcc, 0xc8, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xaa, 0xaa, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9c, 0xcc, 0xcc, 0xcc, + 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, + 0xcc, 0xc8, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, + + /* U+00B2 "²" */ + 0x0, 0x0, 0x3, 0x8c, 0xef, 0xfe, 0xc9, 0x40, + 0x0, 0x0, 0x0, 0x1b, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc2, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe1, 0x0, 0xb, 0xff, 0xff, + 0xd8, 0x66, 0x8e, 0xff, 0xff, 0xa0, 0x3, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x1d, 0xff, 0xff, 0x0, + 0x8f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xf2, 0x1, 0x34, 0x65, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3e, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xaf, 0xff, 0xfe, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x3, 0xef, 0xff, + 0xfc, 0x10, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xe5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xd6, 0x66, 0x66, + 0x66, 0x66, 0x62, 0x6, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x50, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, + + /* U+00B3 "³" */ + 0x0, 0x0, 0x6, 0xad, 0xff, 0xfd, 0xb7, 0x20, + 0x0, 0x0, 0x0, 0x3e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x80, 0x0, 0xc, 0xff, 0xff, + 0x84, 0x23, 0x8f, 0xff, 0xff, 0x10, 0x4, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x6f, 0xff, 0xf3, 0x0, + 0x15, 0x79, 0x70, 0x0, 0x0, 0x2, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0x8f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xd4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xd5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xfe, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x12, 0x5c, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x40, 0xbd, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf3, + 0xb, 0xff, 0xfc, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0x0, 0x5f, 0xff, 0xfc, 0x30, 0x0, 0x3d, + 0xff, 0xff, 0xa0, 0x0, 0xbf, 0xff, 0xff, 0xed, + 0xef, 0xff, 0xff, 0xe1, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd2, 0x0, 0x0, 0x0, + 0x6d, 0xff, 0xff, 0xff, 0xfe, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x2, 0x57, 0x77, 0x52, 0x0, 0x0, + 0x0, + + /* U+00B5 "µ" */ + 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xf4, 0xf, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xf4, 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf4, 0xf, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xf4, 0xf, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xf4, 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf4, 0xf, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xf4, 0xf, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf4, + 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xf4, 0xf, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xf4, 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf4, 0xf, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xf4, 0xf, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xf4, 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf4, 0xf, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xf4, 0xf, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf4, + 0xf, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xf4, 0xf, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xf4, 0xf, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf4, 0xf, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xf4, 0xf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xf4, 0xf, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0xf, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xf4, 0xf, 0xff, 0xff, 0xfd, 0x10, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf4, + 0xf, 0xff, 0xff, 0xff, 0xd2, 0x0, 0x0, 0x0, + 0x1c, 0xff, 0xff, 0xff, 0xf4, 0xf, 0xff, 0xff, + 0xff, 0xff, 0x95, 0x33, 0x59, 0xff, 0xff, 0xff, + 0xff, 0xf4, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xcf, 0xff, 0xf4, 0xf, + 0xff, 0xff, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x5f, 0xff, 0xf4, 0xf, 0xff, 0xff, 0x6, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x4f, 0xff, + 0xf4, 0xf, 0xff, 0xff, 0x0, 0x2b, 0xff, 0xff, + 0xff, 0xe6, 0x0, 0x4f, 0xff, 0xf4, 0xf, 0xff, + 0xff, 0x0, 0x0, 0x15, 0x77, 0x63, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+00B6 "¶" */ + 0x0, 0x0, 0x0, 0x0, 0x26, 0xac, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x4, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x30, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x30, 0x6, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf2, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0x20, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf2, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0x20, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xf2, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0x20, 0x0, 0x0, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf2, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0x20, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf2, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x20, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x1, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5d, 0xff, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x69, 0xae, 0xff, 0xff, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xf0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xf0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xf0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xf0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xf0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xf0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xf0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xf0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf2, 0x0, 0x0, + + /* U+00B7 "·" */ + 0xad, 0xdd, 0xdd, 0xc, 0xff, 0xff, 0xf0, 0xcf, + 0xff, 0xff, 0xc, 0xff, 0xff, 0xf0, 0xcf, 0xff, + 0xff, 0xc, 0xff, 0xff, 0xf0, + + /* U+00BB "»" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf6, 0x0, 0x0, 0x1, 0xef, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xf2, 0x0, 0x0, 0x7, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xc0, 0x0, 0x0, + 0xd, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x4f, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x20, + 0x0, 0x0, 0xbf, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xfc, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xf8, 0x0, 0x0, 0x9, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xf3, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x7f, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x80, + 0x0, 0x0, 0xdf, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0x30, 0x0, 0x5, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xfd, 0x0, 0x0, 0xc, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0xcf, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf8, 0x0, 0x0, + 0xd, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xfd, 0x0, 0x0, 0x7, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x30, 0x0, + 0x1, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x9f, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x2f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xf2, 0x0, 0x0, 0xb, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf6, 0x0, + 0x0, 0x4, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xfb, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x6f, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0x60, 0x0, 0x0, 0x1e, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, + 0x0, 0x0, 0x9, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+00BD "½" */ + 0x0, 0x0, 0x0, 0x8, 0xaa, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6a, 0xaa, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1b, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5e, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x4, 0xcf, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xfc, 0xbf, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf7, + 0xa, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xfe, 0x81, 0x0, 0xaf, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0x0, 0x0, 0xa, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x56, 0x65, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x1, 0x9e, 0xff, 0xff, + 0xff, 0xfa, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0x90, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf8, 0x20, 0x13, 0xaf, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x7, 0xef, 0xfd, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x10, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2d, 0xff, + 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xbf, 0xff, 0xfe, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, + 0xfc, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xfd, 0x77, 0x77, 0x77, + 0x77, 0x77, 0x20, 0x0, 0x0, 0x6f, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x2f, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, + 0x0, 0xd, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x2, + 0x88, 0x87, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0384 "΄" */ + 0x0, 0x3, 0xff, 0xff, 0xff, 0x50, 0x0, 0xaf, + 0xff, 0xff, 0x90, 0x0, 0x2f, 0xff, 0xff, 0xc0, + 0x0, 0x9, 0xff, 0xff, 0xe1, 0x0, 0x1, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x8f, 0xff, 0xf7, 0x0, + 0x0, 0x1f, 0xff, 0xfa, 0x0, 0x0, 0x7, 0xff, + 0xfd, 0x0, 0x0, 0x0, + + /* U+0386 "Ά" */ + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0x90, 0x0, + 0x4f, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0x40, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xf7, 0x0, 0x0, 0xc, + 0xff, 0xfe, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x2f, 0xff, 0xf8, 0xef, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xf4, 0xaf, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xf0, 0x4f, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xc0, 0xf, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0x70, 0xa, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0x20, 0x4, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xfd, 0x0, 0x0, 0xef, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xf8, 0x0, 0x0, 0x9f, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0x60, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xfa, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, + 0x88, 0x88, 0x9f, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x60, 0x1, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xd0, + 0x7, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf3, 0xd, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xfa, + + /* U+0388 "Έ" */ + 0x0, 0x0, 0xef, 0xff, 0xff, 0x80, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x7, 0xff, 0xff, 0xfc, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0xe, + 0xff, 0xff, 0xe1, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x6f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x60, 0x0, 0xdf, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x50, 0x5, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xee, 0xee, 0xee, 0xee, + 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + + /* U+0389 "Ή" */ + 0x0, 0x0, 0xef, 0xff, 0xff, 0x80, 0xc, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, 0x0, + 0x6, 0xff, 0xff, 0xfc, 0x0, 0xc, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, 0x0, 0xe, + 0xff, 0xff, 0xe1, 0x0, 0xc, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xfc, 0x0, 0x6f, 0xff, + 0xff, 0x30, 0x0, 0xc, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xfc, 0x0, 0xdf, 0xff, 0xf7, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xfc, 0x5, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xfc, 0xc, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xfc, 0x4f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, + + /* U+038A "Ί" */ + 0x0, 0x0, 0xef, 0xff, 0xff, 0x80, 0xc, 0xff, + 0xff, 0xb0, 0x0, 0x6f, 0xff, 0xff, 0xc0, 0x0, + 0xcf, 0xff, 0xfb, 0x0, 0xe, 0xff, 0xff, 0xe1, + 0x0, 0xc, 0xff, 0xff, 0xb0, 0x6, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0xcf, 0xff, 0xfb, 0x0, 0xdf, + 0xff, 0xf7, 0x0, 0x0, 0xc, 0xff, 0xff, 0xb0, + 0x5f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xfb, 0xc, 0xff, 0xfd, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xb4, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfb, + + /* U+038C "Ό" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0x46, 0x77, 0x76, 0x41, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0x80, 0x0, 0x0, 0x1, + 0x6b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xea, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x1, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xe1, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0x30, 0x0, 0x1c, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf6, 0x0, + 0x2, 0xef, 0xff, 0xff, 0xff, 0xfc, 0x86, 0x44, + 0x56, 0x9d, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xa0, 0x0, 0x2e, + 0xff, 0xff, 0xff, 0xe7, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x29, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xfd, 0x0, 0x1, 0xdf, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2c, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x4f, 0xff, 0xf2, 0x0, 0xa, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2c, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1d, 0xff, 0xff, 0xff, 0xd6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x29, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xdf, 0xff, 0xff, 0xff, 0xfb, 0x75, 0x44, 0x46, + 0x9d, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1b, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6e, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5b, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xea, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x46, 0x77, 0x76, 0x41, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+038E "Ύ" */ + 0x0, 0x0, 0xef, 0xff, 0xff, 0x80, 0x0, 0xdf, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xf7, 0x0, 0x7, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xc0, 0x0, 0xe, 0xff, 0xff, + 0xe1, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0x20, 0x0, 0x6f, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0xdf, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xb0, 0x0, 0x5, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0x10, 0x0, 0xc, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x4f, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xff, 0x60, 0x0, 0x9, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xe1, + 0x0, 0x3f, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xf9, 0x0, 0xcf, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xff, 0x26, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xbe, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+038F "Ώ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0x56, 0x77, 0x65, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0x80, 0x0, 0x0, 0x1, 0x6c, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd8, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x1, 0x9f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0x30, 0x0, 0xb, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf6, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, + 0xfb, 0x75, 0x44, 0x57, 0xbf, 0xff, 0xff, 0xff, + 0xfc, 0x10, 0x0, 0x0, 0x5, 0xff, 0xff, 0xa0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xf8, 0x10, 0x0, + 0x0, 0x0, 0x1, 0x8f, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0xc, 0xff, 0xfd, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xfd, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xdf, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x4f, 0xff, 0xf2, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xc1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1c, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xfd, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xfc, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xbf, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3e, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0x91, 0x0, 0x0, 0x0, 0x19, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, + + /* U+0390 "ΐ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x67, 0x77, 0x70, + 0x0, 0x9, 0xff, 0xff, 0x21, 0x77, 0x77, 0x5d, + 0xff, 0xff, 0x0, 0x1, 0xff, 0xff, 0x60, 0x2f, + 0xff, 0xfb, 0xdf, 0xff, 0xf0, 0x0, 0x7f, 0xff, + 0xa0, 0x2, 0xff, 0xff, 0xbd, 0xff, 0xff, 0x0, + 0xe, 0xff, 0xe1, 0x0, 0x2f, 0xff, 0xfb, 0xdf, + 0xff, 0xf0, 0x6, 0xff, 0xf4, 0x0, 0x2, 0xff, + 0xff, 0xbd, 0xff, 0xff, 0x0, 0xdf, 0xf8, 0x0, + 0x0, 0x2f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0391 "Α" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfe, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf8, 0xef, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xf4, 0xaf, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xf0, 0x5f, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xc0, 0xf, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0x70, 0xa, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0x20, 0x4, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xfd, 0x0, 0x0, 0xef, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xf8, 0x0, 0x0, 0x9f, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0x60, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xfa, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, + 0x88, 0x88, 0x9f, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x60, 0x1, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xd0, + 0x7, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf3, 0xd, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xfa, + + /* U+0392 "Β" */ + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0xdb, 0x84, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe8, 0x10, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe5, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x47, 0xbf, 0xff, 0xff, 0xff, 0x20, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xcf, 0xff, 0xff, 0xb0, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf1, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf5, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf7, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf9, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf9, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf7, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf4, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf0, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x90, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xdf, 0xff, 0xfe, 0x10, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x12, 0x47, 0xcf, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0x30, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x91, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc6, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd4, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x24, 0x7c, 0xff, 0xff, 0xff, 0xf5, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2b, 0xff, 0xff, 0xff, 0x10, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xa0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf1, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf5, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf8, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf9, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf9, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf7, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf6, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf1, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xd0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1a, 0xff, 0xff, 0xff, 0x50, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0x6a, 0xff, 0xff, 0xff, 0xfc, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe2, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xc2, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc5, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xed, 0xb8, 0x51, 0x0, 0x0, 0x0, 0x0, + + /* U+0393 "Γ" */ + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x95, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf9, 0x5f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x95, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x85, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0394 "Δ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xfe, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf7, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xf3, 0xaf, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xf0, 0x5f, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xb0, 0xf, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0x60, 0xa, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0x10, 0x4, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xfc, 0x0, 0x0, 0xef, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xf7, 0x0, 0x0, 0x8f, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0x50, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x60, 0x1, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, + 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf3, 0xd, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + + /* U+0395 "Ε" */ + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x6f, 0xff, 0xff, 0xee, 0xee, 0xee, 0xee, 0xee, + 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xe0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + + /* U+0396 "Ζ" */ + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x30, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x30, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1d, + 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1d, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, + + /* U+0397 "Η" */ + 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, + 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, + 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xf3, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf3, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x5f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, + 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, + 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, + 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xf3, + + /* U+0398 "Θ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x24, 0x67, 0x77, 0x64, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5a, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xfd, 0x96, + 0x54, 0x46, 0x8c, 0xff, 0xff, 0xff, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xff, 0x92, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x7e, 0xff, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xfb, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1a, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xb0, 0x0, 0xe, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x10, 0x3, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xf6, 0x0, 0x8f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xa0, + 0xb, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xfe, 0x0, 0xef, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xf1, 0xf, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0x32, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x9, 0xee, 0xee, 0xee, 0xee, + 0xee, 0xee, 0xee, 0xeb, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xf4, 0x3f, 0xff, 0xff, 0x70, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x53, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xf6, 0x4f, 0xff, 0xff, 0x60, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x63, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xf5, 0x2f, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0x51, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xf3, 0xe, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0x10, 0xbf, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xe0, 0x7, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xfa, 0x0, 0x3f, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x60, 0x0, + 0xdf, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xf1, 0x0, 0x8, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0x40, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xa1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x9f, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xf8, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x17, 0xef, 0xff, 0xff, 0xfd, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xff, 0xff, 0xc8, 0x64, 0x44, 0x58, 0xcf, + 0xff, 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7e, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x81, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xae, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x45, 0x67, 0x76, 0x42, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0399 "Ι" */ + 0xaf, 0xff, 0xfd, 0xaf, 0xff, 0xfd, 0xaf, 0xff, + 0xfd, 0xaf, 0xff, 0xfd, 0xaf, 0xff, 0xfd, 0xaf, + 0xff, 0xfd, 0xaf, 0xff, 0xfd, 0xaf, 0xff, 0xfd, + 0xaf, 0xff, 0xfd, 0xaf, 0xff, 0xfd, 0xaf, 0xff, + 0xfd, 0xaf, 0xff, 0xfd, 0xaf, 0xff, 0xfd, 0xaf, + 0xff, 0xfd, 0xaf, 0xff, 0xfd, 0xaf, 0xff, 0xfd, + 0xaf, 0xff, 0xfd, 0xaf, 0xff, 0xfd, 0xaf, 0xff, + 0xfd, 0xaf, 0xff, 0xfd, 0xaf, 0xff, 0xfd, 0xaf, + 0xff, 0xfd, 0xaf, 0xff, 0xfd, 0xaf, 0xff, 0xfd, + 0xaf, 0xff, 0xfd, 0xaf, 0xff, 0xfd, 0xaf, 0xff, + 0xfd, 0xaf, 0xff, 0xfd, 0xaf, 0xff, 0xfd, 0xaf, + 0xff, 0xfd, 0xaf, 0xff, 0xfd, 0xaf, 0xff, 0xfd, + 0xaf, 0xff, 0xfd, 0xaf, 0xff, 0xfd, 0xaf, 0xff, + 0xfd, 0xaf, 0xff, 0xfd, 0xaf, 0xff, 0xfd, 0xaf, + 0xff, 0xfd, 0xaf, 0xff, 0xfd, 0xaf, 0xff, 0xfd, + 0xaf, 0xff, 0xfd, 0xaf, 0xff, 0xfd, + + /* U+039A "Κ" */ + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, + 0xf5, 0xb, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, + 0xff, 0xf5, 0x0, 0xbf, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, + 0xff, 0xff, 0xf4, 0x0, 0xb, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xef, 0xff, 0xff, 0xf4, 0x0, 0x0, 0xbf, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xef, 0xff, 0xff, 0xf4, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xef, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, + 0xe3, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, + 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, + 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x1, 0xdf, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x1, 0xdf, 0xff, 0xff, 0xe2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, + 0x0, 0x0, 0x1, 0xdf, 0xff, 0xff, 0xd2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xc0, 0x0, 0x1, 0xdf, 0xff, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x1, 0xdf, 0xff, 0xff, + 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xc0, 0x1, 0xdf, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, 0x1, 0xdf, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xc1, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xfd, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xc1, 0xdf, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x3, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0xb, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0xbf, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0x90, 0x0, 0xb, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0x50, + 0x0, 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xfe, 0x10, 0xb, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xfc, 0x0, 0xbf, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xf8, 0xb, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xf3, + + /* U+039B "Λ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0x8f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xc1, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xf7, 0xd, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0x20, 0x7f, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xd0, 0x2, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf7, 0x0, 0xd, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x20, + 0x0, 0x7f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xc0, 0x0, 0x2, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf6, 0x0, 0x0, + 0xc, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x6f, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x10, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x9f, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0x30, 0x0, 0xe, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xf9, 0x0, 0x5, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xe0, + 0x0, 0xbf, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0x50, 0x1f, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xfb, 0x7, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xf1, + + /* U+039C "Μ" */ + 0xaf, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xaf, 0xff, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, + 0xaf, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xff, 0xaf, 0xff, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xff, 0xff, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, + 0xaf, 0xff, 0xfe, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0xef, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xcf, 0xff, 0xff, + 0xaf, 0xff, 0xfa, 0x9f, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0x6f, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0x4f, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xfc, 0x5f, 0xff, 0xff, + 0xaf, 0xff, 0xfa, 0xe, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf6, 0x5f, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0x9, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xf1, 0x5f, 0xff, 0xff, + 0xaf, 0xff, 0xfa, 0x3, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xb0, 0x5f, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0x0, + 0xef, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0x60, 0x5f, 0xff, 0xff, + 0xaf, 0xff, 0xfa, 0x0, 0x9f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0x10, 0x5f, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0x0, + 0x3f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xfb, 0x0, 0x5f, 0xff, 0xff, + 0xaf, 0xff, 0xfa, 0x0, 0xe, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf5, + 0x0, 0x5f, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0x0, + 0x9, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf0, 0x0, 0x5f, 0xff, 0xff, + 0xaf, 0xff, 0xfa, 0x0, 0x3, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xb0, + 0x0, 0x5f, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0x0, + 0x0, 0xef, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0x50, 0x0, 0x5f, 0xff, 0xff, + 0xaf, 0xff, 0xfa, 0x0, 0x0, 0x8f, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0x0, + 0x0, 0x3f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xfa, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xaf, 0xff, 0xfa, 0x0, 0x0, 0xe, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf5, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0x0, + 0x0, 0x8, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xf0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xaf, 0xff, 0xfa, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xa0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xf1, 0x0, 0x0, 0x1, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xaf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xf6, 0x0, 0x0, 0x6, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xfb, 0x0, 0x0, 0xc, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xaf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0x10, 0x0, 0x1f, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0x50, 0x0, 0x6f, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xaf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xb0, 0x0, 0xcf, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf0, 0x1, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xaf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xf5, 0x7, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfa, 0xc, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xaf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0x2f, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xbf, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xaf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xaf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xaf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xaf, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + + /* U+039D "Ν" */ + 0x6f, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xf4, 0x6f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xf4, 0x6f, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xf4, 0x6f, 0xff, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf4, 0x6f, + 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf4, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xf4, 0x6f, 0xff, 0xfd, 0xcf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xf4, 0x6f, 0xff, 0xfd, 0x2f, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xfd, 0x7, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xfd, 0x0, + 0xcf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xfd, + 0x0, 0x3f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xf4, 0x6f, 0xff, + 0xfd, 0x0, 0x8, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf4, 0x6f, + 0xff, 0xfd, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf4, + 0x6f, 0xff, 0xfd, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xf4, 0x6f, 0xff, 0xfd, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xf4, 0x6f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xf4, 0x6f, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf4, 0x6f, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf4, + 0x6f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0x60, 0x0, 0x0, 0xff, 0xff, + 0xf4, 0x6f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0xff, + 0xff, 0xf4, 0x6f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x60, + 0x0, 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xf1, 0x0, 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xfb, 0x0, 0xff, 0xff, 0xf4, 0x6f, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0x60, 0xff, 0xff, 0xf4, 0x6f, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xf1, 0xff, 0xff, 0xf4, + 0x6f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xfb, 0xff, 0xff, + 0xf4, 0x6f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xf4, 0x6f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xff, 0xff, 0xf4, 0x6f, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xf4, 0x6f, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xf4, 0x6f, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xf4, + 0x6f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xf4, 0x6f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xf4, + + /* U+039E "Ξ" */ + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x7, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, + 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + + /* U+039F "Ο" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x24, 0x67, 0x77, 0x64, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5a, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xfd, 0x96, + 0x54, 0x46, 0x8c, 0xff, 0xff, 0xff, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xff, 0x92, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x7e, 0xff, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xfb, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1a, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xb0, 0x0, 0xe, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x10, 0x3, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xf6, 0x0, 0x8f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xa0, + 0xb, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xfe, 0x0, 0xef, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xf1, 0xf, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0x32, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xf4, 0x3f, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x53, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xf6, 0x4f, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x63, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xf5, 0x2f, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0x51, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xf3, 0xe, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0x10, 0xbf, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xe0, 0x7, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xfa, 0x0, 0x3f, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x60, 0x0, + 0xdf, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xf1, 0x0, 0x8, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0x40, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xa1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x9f, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xf8, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x17, 0xef, 0xff, 0xff, 0xfd, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xff, 0xff, 0xc8, 0x64, 0x44, 0x58, 0xcf, + 0xff, 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7e, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x81, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xae, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x45, 0x67, 0x76, 0x42, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A0 "Π" */ + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf3, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf3, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, + 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, + 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, + 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, + 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, 0x5f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, + 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xf3, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xf3, + + /* U+03A1 "Ρ" */ + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0xca, 0x85, 0x10, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xb4, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfb, 0x0, 0x8, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x59, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x8f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, + 0xff, 0xff, 0xe0, 0x8, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0x50, 0x8f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xfb, 0x8, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xe0, 0x8f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x8, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf2, 0x8f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x28, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf0, 0x8f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x8, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xc0, + 0x8f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf7, + 0x8, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0x20, 0x8f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xa0, 0x8, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x25, 0x9e, 0xff, 0xff, 0xff, + 0xf2, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x81, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xca, 0x73, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A3 "Σ" */ + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x60, 0xdf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x60, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x60, 0xbf, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1d, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xef, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2e, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + + /* U+03A4 "Τ" */ + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf2, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf2, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf2, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf2, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+03A5 "Υ" */ + 0x8f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xfd, 0x0, 0xdf, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x30, 0x3, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0x80, 0x0, 0x8, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xf6, 0x0, 0xc, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xe0, 0x6, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0x81, 0xef, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0xaf, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+03A6 "Φ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6a, 0xaa, 0xa8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x58, 0xbd, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xdc, 0x96, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x71, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0xba, 0xdf, 0xff, 0xff, 0xab, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0xa4, 0x0, 0x0, + 0x9f, 0xff, 0xfe, 0x0, 0x0, 0x38, 0xff, 0xff, + 0xff, 0xfe, 0x20, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xff, 0xb2, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x19, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0x20, 0x2, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0x90, + 0x8, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xe0, 0xe, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xf4, 0x2f, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf8, 0x5f, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xfa, 0x7f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xfc, 0x8f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfd, 0x9f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xfd, 0x8f, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfc, + 0x7f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xfb, 0x5f, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xf9, 0x2f, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf5, 0xd, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xf1, 0x8, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xc0, 0x1, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0x50, 0x0, 0x8f, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x1, 0xbf, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xfb, 0x30, 0x0, + 0x0, 0x9f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x6e, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xff, 0xfc, 0x84, 0x21, 0x9f, 0xff, + 0xfe, 0x1, 0x36, 0xae, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2c, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x49, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xa5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x57, 0x89, 0xdf, + 0xff, 0xff, 0x98, 0x75, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+03A7 "Χ" */ + 0x0, 0x7f, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xf6, 0x0, 0x2, 0xff, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf2, 0x0, + 0xdf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xb0, 0x8f, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0x8f, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xf7, 0xd, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xfd, 0x0, 0x4f, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x9f, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0x70, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xf8, 0x0, 0xa, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf4, 0x6, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xe1, + + /* U+03A8 "Ψ" */ + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xfd, 0x6f, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xfd, 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfd, 0x6f, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xfd, 0x6f, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xfd, 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfd, 0x6f, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xfd, 0x6f, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfd, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xfd, 0x6f, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xfd, 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfd, 0x6f, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xfd, 0x6f, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xfd, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfc, 0x5f, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xfb, 0x3f, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfa, + 0xf, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xf7, 0xd, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xf4, 0x9, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf0, 0x4, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xb0, 0x0, 0xdf, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x5f, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x4e, 0xff, 0xff, 0xfc, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xff, 0xd5, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x19, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, + 0xff, 0xe8, 0x40, 0x0, 0x8f, 0xff, 0xff, 0x0, + 0x1, 0x5a, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xdb, 0xdf, 0xff, 0xff, 0xcd, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x28, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0x69, 0xcd, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xec, 0xa8, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+03A9 "Ω" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x35, 0x67, 0x76, 0x52, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0x8d, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xc6, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x91, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, + 0xff, 0xea, 0x74, 0x44, 0x58, 0xcf, 0xff, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xef, 0xff, 0xff, 0xfe, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x2b, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xef, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0xa, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0x10, 0x0, 0x1, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xe0, 0x0, 0xc, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0x30, 0x1, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf8, 0x0, 0x5f, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xb0, + 0x7, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xfd, 0x0, 0xaf, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf0, 0xb, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0x10, 0xcf, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf2, 0xc, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0x20, 0xbf, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xf2, 0xb, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0x10, 0x9f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf0, 0x6, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfc, 0x0, + 0x3f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0x90, 0x0, 0xef, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xf5, 0x0, 0xa, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0x10, 0x0, 0x4f, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xa0, 0x0, 0x0, 0xdf, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf4, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xef, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xcf, 0xff, 0xfc, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xfe, 0x60, 0x0, 0x0, 0x0, 0x2b, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x94, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0x4f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa4, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfa, 0x4f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, + + /* U+03AA "Ϊ" */ + 0xf, 0xff, 0xff, 0x40, 0x0, 0x7, 0xff, 0xff, + 0xd0, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x7f, 0xff, + 0xfd, 0xf, 0xff, 0xff, 0x40, 0x0, 0x7, 0xff, + 0xff, 0xd0, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x7f, + 0xff, 0xfd, 0xf, 0xff, 0xff, 0x40, 0x0, 0x7, + 0xff, 0xff, 0xd0, 0xdd, 0xdd, 0xd4, 0x0, 0x0, + 0x6d, 0xdd, 0xdb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xc0, 0x0, + 0x0, + + /* U+03AB "Ϋ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0x90, 0x0, 0x2, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xf9, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x90, + 0x0, 0x2, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf9, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x90, 0x0, + 0x2, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xad, + 0xdd, 0xd8, 0x0, 0x0, 0x2d, 0xdd, 0xdd, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xfd, 0x0, + 0xdf, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0x30, 0x3, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0x80, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0xef, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xf6, 0x0, 0xc, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xe0, 0x6, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0x81, 0xef, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xaf, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03AC "ά" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x46, 0x77, 0x63, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xcf, + 0xff, 0xff, 0xff, 0xe8, 0x10, 0x0, 0x0, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x4, 0xdf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe4, 0x0, 0x5, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x60, 0x9, 0xff, 0xff, 0x90, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xdc, 0xdf, + 0xff, 0xff, 0xf4, 0xe, 0xff, 0xff, 0x50, 0x0, + 0x2f, 0xff, 0xff, 0xfe, 0x61, 0x0, 0x0, 0x5e, + 0xff, 0xff, 0x5f, 0xff, 0xff, 0x10, 0x0, 0xcf, + 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xff, 0xfc, 0x0, 0x4, 0xff, 0xff, + 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xff, 0xf8, 0x0, 0xb, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0xf4, 0x0, 0x1f, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xf1, 0x0, 0x5f, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xd0, + 0x0, 0x8f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x90, 0x0, + 0xbf, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0x60, 0x0, 0xcf, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0x30, 0x0, 0xdf, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0x0, 0x0, 0xef, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xfc, 0x0, 0x0, 0xef, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xfc, 0x0, 0x0, 0xdf, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0x0, 0x0, 0xcf, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x20, + 0x0, 0xbf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x50, 0x0, + 0x7f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0x90, 0x0, 0x4f, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xc0, 0x0, 0xf, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xf0, 0x0, 0xa, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xf3, 0x0, 0x3, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0xdf, 0xff, + 0xfa, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xfd, 0x50, + 0x0, 0x1, 0x8f, 0xff, 0xfd, 0x4f, 0xff, 0xfe, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, 0xdc, + 0xdf, 0xff, 0xff, 0xf4, 0xf, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x80, 0xa, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x3, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x4, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x6, 0xdf, 0xff, 0xff, 0xff, 0xf9, 0x20, + 0x0, 0x0, 0xef, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x2, 0x57, 0x77, 0x63, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+03AD "έ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x25, 0x67, + 0x65, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x18, 0xef, 0xff, 0xff, 0xff, 0xea, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb2, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf3, 0x0, 0xa, 0xff, 0xff, 0xf8, + 0x20, 0x0, 0x49, 0xff, 0xff, 0xe4, 0x0, 0x0, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xc1, 0x0, 0x0, 0x4f, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x5, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xf9, 0x41, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3d, 0xff, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xdf, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0xd8, 0x65, 0x42, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xfe, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0x10, 0x0, 0xf, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x3, 0xfe, + 0x30, 0x0, 0xaf, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x40, 0x3, 0xff, 0xff, + 0xff, 0x81, 0x0, 0x0, 0x6c, 0xff, 0xff, 0xff, + 0x40, 0xa, 0xff, 0xff, 0xff, 0xfd, 0xcd, 0xff, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x20, 0x0, 0x0, 0x0, 0x4, 0xbf, 0xff, + 0xff, 0xff, 0xfe, 0xa4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0x67, 0x77, 0x52, 0x0, 0x0, + 0x0, 0x0, + + /* U+03AE "ή" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x36, 0x77, 0x64, 0x10, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf8, 0x0, 0x3, 0xaf, 0xff, + 0xff, 0xff, 0xfc, 0x40, 0x0, 0x0, 0x1f, 0xff, + 0xf8, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfb, 0x10, 0x0, 0x1f, 0xff, 0xf8, 0xc, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd1, 0x0, + 0x1f, 0xff, 0xf8, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x0, 0x1f, 0xff, 0xfe, + 0xff, 0xff, 0xa5, 0x10, 0x1, 0x5c, 0xff, 0xff, + 0xff, 0x50, 0x1f, 0xff, 0xff, 0xff, 0xe3, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x1f, + 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xe0, 0x1f, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xf1, 0x1f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xf3, 0x1f, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xf4, 0x1f, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf5, + 0x1f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf5, 0x1f, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf6, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x1f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xf6, 0x1f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf6, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x1f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf6, 0x1f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, + 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x1f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf6, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x1f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xf6, 0x1f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf6, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x1f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf6, 0x1f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, + 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x1f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf6, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf6, + + /* U+03AF "ί" */ + 0x0, 0x7, 0xff, 0xff, 0xff, 0x20, 0x0, 0xef, + 0xff, 0xff, 0x50, 0x0, 0x6f, 0xff, 0xff, 0x80, + 0x0, 0xd, 0xff, 0xff, 0xb0, 0x0, 0x5, 0xff, + 0xff, 0xe1, 0x0, 0x0, 0xcf, 0xff, 0xf3, 0x0, + 0x0, 0x4f, 0xff, 0xf6, 0x0, 0x0, 0xb, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0x0, 0x0, 0x0, + + /* U+03B0 "ΰ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xf8, 0x0, 0x2, 0xff, + 0xff, 0x60, 0xbf, 0xff, 0xf3, 0x0, 0x6, 0xff, + 0xff, 0x80, 0x0, 0xaf, 0xff, 0xa0, 0xb, 0xff, + 0xff, 0x30, 0x0, 0x6f, 0xff, 0xf8, 0x0, 0x2f, + 0xff, 0xd0, 0x0, 0xbf, 0xff, 0xf3, 0x0, 0x6, + 0xff, 0xff, 0x80, 0xa, 0xff, 0xf2, 0x0, 0xb, + 0xff, 0xff, 0x30, 0x0, 0x6f, 0xff, 0xf8, 0x2, + 0xff, 0xf6, 0x0, 0x0, 0xbf, 0xff, 0xf3, 0x0, + 0x2, 0x77, 0x77, 0x30, 0x47, 0x76, 0x0, 0x0, + 0x5, 0x77, 0x77, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfe, 0x2f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xe2, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfe, + 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xe2, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xfe, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xe2, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xfe, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xe2, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xfe, 0x2f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xe2, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xfe, 0x2f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xe2, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xfe, 0x2f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xe2, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfe, 0x2f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xe2, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfe, 0x2f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xe1, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfd, + 0x1f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xc0, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xfb, 0xd, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0x70, 0xaf, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xf4, 0x5, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfe, 0x0, 0xe, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0x80, 0x0, 0x6f, 0xff, 0xff, 0xfa, + 0x20, 0x0, 0x4, 0xcf, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xff, 0xec, 0xce, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x18, 0xef, 0xff, 0xff, 0xff, 0xfb, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x25, 0x67, + 0x75, 0x40, 0x0, 0x0, 0x0, 0x0, + + /* U+03B1 "α" */ + 0x0, 0x0, 0x0, 0x0, 0x1, 0x46, 0x77, 0x63, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xcf, 0xff, 0xff, 0xff, 0xe8, + 0x10, 0x0, 0x0, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x4, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe4, + 0x0, 0x5, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, + 0x9, 0xff, 0xff, 0x90, 0x0, 0x6, 0xff, 0xff, + 0xff, 0xff, 0xdc, 0xdf, 0xff, 0xff, 0xf4, 0xe, + 0xff, 0xff, 0x50, 0x0, 0x2f, 0xff, 0xff, 0xfe, + 0x61, 0x0, 0x0, 0x5e, 0xff, 0xff, 0x5f, 0xff, + 0xff, 0x10, 0x0, 0xcf, 0xff, 0xff, 0xc1, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xfc, + 0x0, 0x4, 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0xb, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x1f, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xf1, 0x0, 0x5f, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xd0, 0x0, 0x8f, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0x90, 0x0, 0xbf, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0x60, 0x0, 0xcf, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0x30, 0x0, 0xdf, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x0, + 0x0, 0xef, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xfc, 0x0, 0x0, + 0xef, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xfc, 0x0, 0x0, 0xdf, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0x0, 0x0, 0xcf, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0x20, 0x0, 0xbf, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0x50, 0x0, 0x7f, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0x90, 0x0, 0x4f, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xc0, 0x0, 0xf, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf0, + 0x0, 0xa, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0x3, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2e, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x2, + 0xef, 0xff, 0xdf, 0xff, 0xfa, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xfd, 0x50, 0x0, 0x1, 0x8f, 0xff, + 0xfd, 0x4f, 0xff, 0xfe, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xff, 0xdc, 0xdf, 0xff, 0xff, 0xf4, + 0xf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0xa, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x3, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x4, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x6, 0xdf, 0xff, + 0xff, 0xff, 0xf9, 0x20, 0x0, 0x0, 0xef, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x2, 0x57, 0x77, + 0x63, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03B2 "β" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x25, 0x67, 0x65, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x8e, 0xff, 0xff, 0xff, 0xff, 0xa3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2d, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x10, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xcb, 0xdf, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xfb, 0x40, 0x0, 0x0, 0x5d, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0x10, 0x0, 0x0, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0x70, 0x0, + 0x5, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xc0, 0x0, 0x9, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xf0, 0x0, 0xc, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xf2, 0x0, 0xe, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf3, 0x0, + 0xf, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xf2, 0x0, 0xf, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf0, 0x0, 0xf, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xb0, 0x0, 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x50, 0x0, + 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, 0xf, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xe1, 0x0, 0x0, 0xf, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x13, 0x6a, 0xff, 0xff, 0xfd, 0x10, + 0x0, 0x0, 0xf, 0xff, 0xff, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xfe, 0x81, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xb5, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x0, + 0x0, 0x5c, 0xcd, 0xff, 0xff, 0xff, 0xff, 0xd3, + 0x0, 0x0, 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x5b, 0xff, 0xff, 0xff, 0x60, 0x0, + 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3d, 0xff, 0xff, 0xf5, 0x0, 0xf, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xdf, 0xff, 0xff, 0x20, 0xf, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0x90, 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf1, + 0xf, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xf5, 0xf, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xf9, 0xf, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xfa, 0xf, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfb, + 0xf, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfa, 0xf, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xf8, 0xf, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xf5, 0xf, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf0, + 0xf, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0x90, 0xf, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0x20, 0xf, 0xff, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x2c, 0xff, 0xff, + 0xf8, 0x0, 0xf, 0xff, 0xff, 0x9f, 0xff, 0xfe, + 0x96, 0x45, 0x7b, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0xf, 0xff, 0xff, 0xa, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0xf, 0xff, + 0xff, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0xf, 0xff, 0xff, 0x0, + 0x1, 0x9e, 0xff, 0xff, 0xff, 0xfe, 0x92, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x35, 0x77, 0x65, 0x30, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+03B3 "γ" */ + 0x1f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x10, 0xbf, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xb0, 0x6, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xf5, 0x0, 0xf, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0x0, 0x0, 0xaf, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xa0, + 0x0, 0x4, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xf4, 0x0, 0x0, + 0xe, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xf2, 0x0, 0x0, 0x2, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x8f, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfd, 0x0, 0x0, + 0xd, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xf3, 0x0, 0x3, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0x80, 0x0, 0x9f, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xfe, 0x0, 0xe, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xf4, 0x4, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x90, + 0xaf, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfe, 0x1f, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xfa, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+03B4 "δ" */ + 0x0, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x52, + 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x21, 0x0, + 0x0, 0x0, 0x3, 0xef, 0xff, 0xfe, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xdf, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xcf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xb1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xe4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3d, 0xff, 0xff, + 0xfc, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x39, 0xce, 0xff, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x1c, 0xff, 0xff, 0xff, 0xff, + 0xee, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xa4, 0x0, 0x0, + 0x39, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xfe, 0x40, 0x0, 0x0, 0x0, 0x2, + 0xcf, 0xff, 0xff, 0x80, 0x0, 0x1, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0x30, 0x0, 0x8f, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xfc, 0x0, 0xf, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf3, + 0x3, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x80, 0x7f, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xfc, 0xb, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xf0, 0xcf, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0x1d, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xf2, 0xef, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x3e, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xf3, 0xdf, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0x2c, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xf1, 0xaf, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0x6, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xc0, + 0x2f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf8, 0x0, 0xdf, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0x30, 0x6, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xd0, 0x0, 0xe, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xe4, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xfa, 0x30, 0x0, + 0x1, 0x6e, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, + 0x1, 0xdf, 0xff, 0xff, 0xff, 0xec, 0xcd, 0xff, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x1, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x29, 0xef, + 0xff, 0xff, 0xff, 0xfe, 0x92, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x25, 0x67, + 0x76, 0x52, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03B5 "ε" */ + 0x0, 0x0, 0x0, 0x0, 0x25, 0x67, 0x65, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x18, 0xef, + 0xff, 0xff, 0xff, 0xea, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xb2, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0xa, 0xff, 0xff, 0xf8, 0x20, 0x0, + 0x49, 0xff, 0xff, 0xe4, 0x0, 0x0, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xc1, 0x0, + 0x0, 0x4f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x20, 0x0, 0x0, 0x5, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf9, 0x41, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3d, 0xff, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xdf, + 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xd8, 0x65, 0x42, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xfe, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0x10, 0x0, 0xf, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xfe, 0x30, 0x0, + 0xaf, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0x40, 0x3, 0xff, 0xff, 0xff, 0x81, + 0x0, 0x0, 0x6c, 0xff, 0xff, 0xff, 0x40, 0xa, + 0xff, 0xff, 0xff, 0xfd, 0xcd, 0xff, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x20, + 0x0, 0x0, 0x0, 0x4, 0xbf, 0xff, 0xff, 0xff, + 0xfe, 0xa4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0x67, 0x77, 0x52, 0x0, 0x0, 0x0, 0x0, + + /* U+03B6 "ζ" */ + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x12, 0x22, 0x22, 0x22, 0x22, 0x25, + 0xef, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfe, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1c, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xdf, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xc1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xfe, 0x61, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0xff, 0xdb, 0x97, 0x53, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x70, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x20, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x1, 0x6a, + 0xde, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x37, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x17, 0xaf, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xa3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x65, 0x30, + 0x0, 0x0, 0x0, 0x0, + + /* U+03B7 "η" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x36, 0x77, + 0x64, 0x10, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf8, + 0x0, 0x3, 0xaf, 0xff, 0xff, 0xff, 0xfc, 0x40, + 0x0, 0x0, 0x1f, 0xff, 0xf8, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0x10, 0x0, 0x1f, + 0xff, 0xf8, 0xc, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd1, 0x0, 0x1f, 0xff, 0xf8, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x0, 0x1f, 0xff, 0xfe, 0xff, 0xff, 0xa5, 0x10, + 0x1, 0x5c, 0xff, 0xff, 0xff, 0x50, 0x1f, 0xff, + 0xff, 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xb0, 0x1f, 0xff, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xe0, + 0x1f, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xf1, 0x1f, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xf3, 0x1f, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf4, 0x1f, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xf5, 0x1f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf5, 0x1f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x1f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf6, 0x1f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, + 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x1f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf6, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x1f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xf6, 0x1f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf6, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x1f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf6, 0x1f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, + 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x1f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf6, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x1f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xf6, 0x1f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf6, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x1f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf6, + + /* U+03B8 "θ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x67, 0x76, + 0x41, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4b, 0xff, 0xff, 0xff, 0xff, 0xc6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1b, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, 0xec, 0xce, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xc4, 0x0, 0x0, 0x3a, 0xff, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xf9, 0x0, 0x0, 0xaf, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0x0, 0x0, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0x40, 0x4, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x90, + 0x8, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xc0, 0xb, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xf0, 0xe, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xf2, 0xf, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf4, + 0x2f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf6, 0x3f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xf8, 0x4f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xf9, 0x5f, 0xff, 0xfe, 0x22, 0x22, 0x22, + 0x22, 0x22, 0x22, 0x22, 0x22, 0xaf, 0xff, 0xfa, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x6f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0x6f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x5f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfa, 0x4f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf9, 0x3f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf8, 0x2f, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf6, + 0xf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xf4, 0xe, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xf2, 0xb, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xf0, 0x8, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xc0, + 0x4, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0x90, 0x0, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0x40, 0x0, 0xbf, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf9, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xc4, 0x0, 0x0, 0x2a, 0xff, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, + 0xfd, 0xce, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4b, 0xff, 0xff, 0xff, 0xff, 0xd6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0x67, 0x76, 0x41, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03B9 "ι" */ + 0x2f, 0xff, 0xff, 0x2f, 0xff, 0xff, 0x2f, 0xff, + 0xff, 0x2f, 0xff, 0xff, 0x2f, 0xff, 0xff, 0x2f, + 0xff, 0xff, 0x2f, 0xff, 0xff, 0x2f, 0xff, 0xff, + 0x2f, 0xff, 0xff, 0x2f, 0xff, 0xff, 0x2f, 0xff, + 0xff, 0x2f, 0xff, 0xff, 0x2f, 0xff, 0xff, 0x2f, + 0xff, 0xff, 0x2f, 0xff, 0xff, 0x2f, 0xff, 0xff, + 0x2f, 0xff, 0xff, 0x2f, 0xff, 0xff, 0x2f, 0xff, + 0xff, 0x2f, 0xff, 0xff, 0x2f, 0xff, 0xff, 0x2f, + 0xff, 0xff, 0x2f, 0xff, 0xff, 0x2f, 0xff, 0xff, + 0x2f, 0xff, 0xff, 0x2f, 0xff, 0xff, 0x2f, 0xff, + 0xff, 0x2f, 0xff, 0xff, 0x2f, 0xff, 0xff, 0x2f, + 0xff, 0xff, + + /* U+03BA "κ" */ + 0x3f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0x40, 0x3f, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xf3, 0x0, 0x3f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xfe, 0x30, 0x0, 0x3f, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xe2, 0x0, 0x0, 0x3f, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xfd, 0x10, 0x0, + 0x0, 0x3f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xfd, 0x0, 0x0, 0xa, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfd, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xfd, 0x0, 0xb, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfd, + 0x0, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xfd, 0xc, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xfe, 0xcf, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xe2, 0xbf, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfe, + 0x10, 0x1d, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xfd, 0x0, 0x2, 0xef, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xfd, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfd, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x1, 0xdf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x3f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x3f, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x3f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xe2, 0x0, 0x3f, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xfd, 0x0, 0x3f, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xb0, 0x3f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0xf8, + + /* U+03BB "λ" */ + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xfd, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0x2f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xa0, + 0xbf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xf4, 0x5, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xfe, 0x0, 0xf, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0x80, 0x0, 0x9f, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xf2, 0x0, 0x3, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xfc, 0x0, + 0x0, 0xd, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x7f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x30, + 0x0, 0xa, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf9, 0x0, 0x0, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xf0, 0x0, 0x6f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0x50, 0xc, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xfb, 0x2, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xf1, + + /* U+03BC "μ" */ + 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xf4, 0xf, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xf4, 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf4, 0xf, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xf4, 0xf, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xf4, 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf4, 0xf, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xf4, 0xf, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf4, + 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xf4, 0xf, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xf4, 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf4, 0xf, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xf4, 0xf, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xf4, 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf4, 0xf, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xf4, 0xf, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf4, + 0xf, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xf4, 0xf, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xf4, 0xf, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf4, 0xf, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xf4, 0xf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xf4, 0xf, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0xf, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xf4, 0xf, 0xff, 0xff, 0xfd, 0x10, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf4, + 0xf, 0xff, 0xff, 0xff, 0xd2, 0x0, 0x0, 0x0, + 0x1c, 0xff, 0xff, 0xff, 0xf4, 0xf, 0xff, 0xff, + 0xff, 0xff, 0x95, 0x33, 0x59, 0xff, 0xff, 0xff, + 0xff, 0xf4, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xcf, 0xff, 0xf4, 0xf, + 0xff, 0xff, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x5f, 0xff, 0xf4, 0xf, 0xff, 0xff, 0x6, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x4f, 0xff, + 0xf4, 0xf, 0xff, 0xff, 0x0, 0x2b, 0xff, 0xff, + 0xff, 0xe6, 0x0, 0x4f, 0xff, 0xf4, 0xf, 0xff, + 0xff, 0x0, 0x0, 0x15, 0x77, 0x63, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+03BD "ν" */ + 0x1f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x20, 0xbf, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xc0, 0x5, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xf6, 0x0, 0xe, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0x0, 0x0, 0x8f, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x90, + 0x0, 0x2, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xf3, 0x0, 0x0, + 0xc, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf5, 0x0, 0x0, 0x3, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x9f, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x10, 0x0, + 0xe, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xf6, 0x0, 0x5, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xc0, 0x0, 0xaf, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0x10, 0x1f, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xf6, 0x6, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xc0, + 0xbf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x2f, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xfb, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+03BE "ξ" */ + 0x0, 0x0, 0x0, 0x0, 0x5, 0x8b, 0xde, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x1, 0x8e, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x4, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xfa, 0x75, 0x44, 0x44, 0x43, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfe, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xfd, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xe9, 0x75, + 0x44, 0x44, 0x42, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x2, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x37, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x5, 0xef, 0xff, + 0xff, 0xea, 0x63, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xfd, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xe9, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0xb9, 0x62, 0x0, 0x0, + 0x0, 0x0, 0x1c, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x40, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x1, 0x8e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x3, + 0x79, 0xcf, 0xff, 0xff, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x6d, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4d, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3d, 0xff, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xc4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xed, 0xb8, 0x30, 0x0, 0x0, + 0x0, + + /* U+03BF "ο" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x57, 0x77, + 0x52, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xcf, 0xff, 0xff, 0xff, 0xfe, + 0x93, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x1, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x40, + 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xff, + 0xed, 0xce, 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xff, 0xf8, 0x20, 0x0, + 0x1, 0x6e, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xd2, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xf5, 0x0, 0xb, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xd0, 0x1, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0x40, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf8, 0x8, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xc0, 0xbf, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xd, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xf1, 0xef, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0x2f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf3, + 0xef, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x3d, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xf2, 0xcf, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xb, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xe0, 0x8f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfc, + 0x4, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x80, 0xf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xf3, 0x0, 0x9f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xfd, 0x0, 0x2, 0xff, 0xff, 0xfd, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0x60, 0x0, 0xa, 0xff, 0xff, 0xfd, 0x20, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0x82, 0x0, + 0x0, 0x16, 0xef, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xff, 0xff, 0xfe, 0xcc, 0xdf, + 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7c, + 0xff, 0xff, 0xff, 0xff, 0xd9, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x45, + 0x77, 0x64, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03C0 "π" */ + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x12, 0x22, 0x22, 0x22, + 0xdf, 0xff, 0xf6, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x25, 0xff, 0xff, 0xe2, 0x22, 0x22, 0x22, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, + + /* U+03C1 "ρ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x25, 0x67, 0x76, + 0x41, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0x9e, 0xff, 0xff, 0xff, 0xff, 0xd7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xec, 0xce, + 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x93, 0x0, 0x0, 0x28, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xe3, 0x0, 0x0, 0x0, 0x0, 0x2d, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0xaf, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfe, 0x0, + 0x0, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x60, 0x5, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xd0, 0x9, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xf2, 0xc, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf6, + 0xf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfa, 0x1f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xfc, 0x2f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xfd, 0x4f, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xfe, + 0x4f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfe, 0x4f, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xfd, 0x4f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xfc, 0x4f, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfa, + 0x4f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf6, 0x4f, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xf3, 0x4f, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xe0, 0x4f, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x70, + 0x4f, 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x10, 0x4f, 0xff, + 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x1b, + 0xff, 0xff, 0xf7, 0x0, 0x4f, 0xff, 0xff, 0xff, + 0xff, 0x82, 0x0, 0x0, 0x17, 0xef, 0xff, 0xff, + 0xb0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xec, 0xcd, 0xff, 0xff, 0xff, 0xfe, 0x10, 0x0, + 0x4f, 0xff, 0xfd, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd2, 0x0, 0x0, 0x4f, 0xff, + 0xfd, 0x6, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfd, 0x0, + 0x8, 0xdf, 0xff, 0xff, 0xff, 0xfa, 0x30, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xfd, 0x0, 0x0, 0x2, + 0x56, 0x77, 0x63, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+03C2 "ς" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x24, + 0x67, 0x76, 0x54, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0xb2, 0x0, 0x0, 0x0, 0x0, 0x8, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x4, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0xdc, 0xce, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xc6, + 0x20, 0x0, 0x0, 0x1, 0x59, 0x30, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xd4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xff, 0xf8, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xff, + 0xfd, 0x83, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe9, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x5a, 0xef, 0xff, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0x6b, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x19, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x41, 0x0, 0x26, 0xcf, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xff, 0xff, 0xa2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x17, 0x9b, 0xcb, 0xa9, 0x51, + 0x0, 0x0, 0x0, 0x0, + + /* U+03C3 "σ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x45, 0x77, + 0x65, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x17, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x1, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x3e, 0xff, + 0xff, 0xff, 0xfe, 0xcc, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x1, 0xef, + 0xff, 0xff, 0xf7, 0x20, 0x0, 0x1, 0x6e, 0xff, + 0xff, 0xfb, 0x22, 0x22, 0x22, 0x21, 0x0, 0xc, + 0xff, 0xff, 0xfc, 0x10, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0x60, 0x0, 0x0, 0xa, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0x90, 0x0, 0x0, 0xd, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xe0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0xf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0xf, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0x70, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xfb, 0x10, 0x0, + 0x0, 0x0, 0x1, 0xaf, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xe6, + 0x10, 0x0, 0x1, 0x6e, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0xfd, 0xcc, 0xef, 0xff, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x18, 0xdf, 0xff, 0xff, 0xff, 0xfc, + 0x71, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x46, 0x77, 0x64, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03C4 "τ" */ + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x9b, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9b, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf9, 0x12, 0x22, 0x22, 0x22, 0xcf, 0xff, + 0xf7, 0x22, 0x22, 0x22, 0x10, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, + + /* U+03C5 "υ" */ + 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xe2, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xfe, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xe2, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xfe, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xe2, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xfe, 0x2f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xe2, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xfe, 0x2f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xe2, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xfe, 0x2f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xe2, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfe, 0x2f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xe2, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfe, 0x2f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xe2, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfe, + 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xe2, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xfe, 0x1f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xd1, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xfc, 0xf, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xb0, 0xdf, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xf7, 0xa, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x40, + 0x5f, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xe0, 0x0, 0xef, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf8, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xa2, 0x0, 0x0, + 0x4c, 0xff, 0xff, 0xfe, 0x10, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xfe, 0xcc, 0xef, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x1, 0x8e, 0xff, + 0xff, 0xff, 0xff, 0xb5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0x56, 0x77, 0x54, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+03C6 "φ" */ + 0x0, 0x0, 0x0, 0x0, 0x2, 0x57, 0x0, 0x0, + 0x0, 0x36, 0x77, 0x64, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xdf, 0xfe, 0x0, + 0x0, 0x3d, 0xff, 0xff, 0xff, 0xfc, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xcf, 0xff, 0xfa, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xf7, 0x0, 0xd, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x2f, 0xff, 0xff, 0xfe, 0xce, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0xfa, 0x20, 0x0, 0x5f, 0xff, 0xff, 0x70, + 0x0, 0x6f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x7f, 0xff, 0xfe, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xf6, 0x0, 0x3, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xfe, 0x0, + 0xa, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0x60, 0x1f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xc0, 0x5f, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xf1, 0x9f, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xf4, 0xcf, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xf6, 0xdf, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf8, 0xef, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf9, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf8, + 0xef, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xf7, 0xdf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xf5, 0xaf, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xf2, 0x7f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xd0, 0x3f, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0x80, 0xe, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0x20, 0x7, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf8, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xfb, 0x0, 0x0, + 0xef, 0xff, 0xff, 0x30, 0x0, 0x0, 0x8f, 0xff, + 0xf8, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xe3, 0x0, 0x0, 0x8f, + 0xff, 0xf8, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x8f, 0xff, 0xf8, 0x0, 0x3d, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xfe, + 0x72, 0x8f, 0xff, 0xf9, 0x5b, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xa3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x57, 0xcf, 0xff, + 0xfb, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+03C7 "χ" */ + 0x6, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf1, 0x0, + 0xdf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0x80, 0x0, 0x5f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x10, 0x0, 0xd, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x9f, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0x90, 0x0, 0x2, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xf1, 0x0, 0x9, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf8, 0x0, 0x2f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0x10, 0xaf, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0x82, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xfb, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xfd, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xa4, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0x20, 0xcf, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xfa, 0x0, 0x4f, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xf2, 0x0, 0xc, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0x90, 0x0, 0x4, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0x10, 0x0, 0x0, 0xcf, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x9f, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfe, + 0x10, 0x2, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x80, + 0xb, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf1, 0x3f, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xfa, + + /* U+03C8 "ψ" */ + 0x8f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xd8, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xfd, 0x8f, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xd8, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfd, 0x8f, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xd8, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xfd, 0x8f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xd8, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xfd, 0x8f, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xd8, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfd, 0x8f, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xd8, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xfd, 0x8f, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xd8, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xfd, 0x8f, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xd8, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfd, + 0x8f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xc7, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xfc, 0x6f, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xb5, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf9, 0x3f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x70, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xf4, 0xb, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0x0, 0x5f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xb0, 0x0, 0xcf, 0xff, 0xff, + 0xb1, 0x0, 0x0, 0xe, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xf3, 0x0, 0x2, 0xff, + 0xff, 0xff, 0xf9, 0x30, 0x0, 0xef, 0xff, 0xf3, + 0x0, 0x27, 0xdf, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xdf, 0xff, + 0xff, 0xdd, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x3, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x28, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xea, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0x56, 0x7e, 0xff, 0xff, 0x97, + 0x64, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03C9 "ω" */ + 0x0, 0x0, 0x5f, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0x80, 0x0, 0xa, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xfe, 0x0, 0x0, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf4, 0x0, + 0x5f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0x77, 0x77, 0x10, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0x90, 0x9, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfe, + 0x0, 0xdf, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xf2, 0xf, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0x53, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf8, 0x5f, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xa7, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xfc, 0x8f, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xc8, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xfc, + 0x7f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xc6, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xfb, 0x5f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xa3, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf7, 0xf, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x40, 0xcf, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xf1, 0x7, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, 0x0, + 0x1f, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0x60, 0x0, 0xbf, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x1, 0xdf, 0xff, 0x5e, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xf1, + 0x0, 0x2, 0xff, 0xff, 0xff, 0x50, 0x0, 0x3, + 0xef, 0xff, 0xc0, 0x7f, 0xff, 0xf6, 0x0, 0x0, + 0x2d, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0xd9, 0x9c, 0xff, 0xff, 0xf2, 0x0, + 0xdf, 0xff, 0xfe, 0x99, 0xbf, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x2, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x10, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x2, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x3, 0xbf, 0xff, + 0xff, 0xff, 0xa2, 0x0, 0x0, 0x0, 0x0, 0x8e, + 0xff, 0xff, 0xff, 0xc5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x15, 0x77, 0x64, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0x67, 0x65, 0x10, + 0x0, 0x0, 0x0, 0x0, + + /* U+03CA "ϊ" */ + 0x9f, 0xff, 0xfc, 0x0, 0x0, 0xf, 0xff, 0xff, + 0x59, 0xff, 0xff, 0xc0, 0x0, 0x0, 0xff, 0xff, + 0xf5, 0x9f, 0xff, 0xfc, 0x0, 0x0, 0xf, 0xff, + 0xff, 0x59, 0xff, 0xff, 0xc0, 0x0, 0x0, 0xff, + 0xff, 0xf5, 0x9f, 0xff, 0xfc, 0x0, 0x0, 0xf, + 0xff, 0xff, 0x57, 0xdd, 0xdd, 0xa0, 0x0, 0x0, + 0xdd, 0xdd, 0xd4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0x0, 0x0, 0x0, + + /* U+03CB "ϋ" */ + 0x0, 0x0, 0x1f, 0xff, 0xff, 0x40, 0x0, 0x8, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x8f, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x40, 0x0, + 0x8, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x8f, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x40, + 0x0, 0x8, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0xdd, 0xdd, 0xd3, 0x0, 0x0, 0x6d, 0xdd, + 0xdb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xe2, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfe, 0x2f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xe2, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfe, + 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xe2, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xfe, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xe2, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xfe, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xe2, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xfe, 0x2f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xe2, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xfe, 0x2f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xe2, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xfe, 0x2f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xe2, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfe, 0x2f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xe2, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfe, 0x1f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xd1, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfc, + 0xf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xb0, 0xdf, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xf7, 0xa, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0x40, 0x5f, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xe0, 0x0, 0xef, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xf8, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xa2, 0x0, 0x0, 0x4c, 0xff, + 0xff, 0xfe, 0x10, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xfe, 0xcc, 0xef, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x8e, 0xff, 0xff, 0xff, + 0xff, 0xb5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0x56, 0x77, 0x54, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+03CC "ό" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0x57, 0x77, 0x52, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xcf, 0xff, 0xff, 0xff, 0xfe, 0x93, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7e, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0x40, 0x0, 0x0, + 0x0, 0x2, 0xef, 0xff, 0xff, 0xff, 0xed, 0xce, + 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xff, 0xf8, 0x20, 0x0, 0x1, 0x6e, + 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xd2, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xf5, 0x0, 0xb, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xd0, + 0x1, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x40, 0x5f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xf8, 0x8, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xc0, 0xbf, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xd, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xf1, 0xef, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x2f, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xf3, 0xef, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0x3d, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xf2, 0xcf, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xb, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xe0, + 0x8f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfc, 0x4, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0x80, 0xf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xf3, 0x0, 0x9f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xfd, 0x0, 0x2, 0xff, 0xff, 0xfd, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x60, + 0x0, 0xa, 0xff, 0xff, 0xfd, 0x20, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xff, 0x82, 0x0, 0x0, 0x16, + 0xef, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xff, 0xfe, 0xcc, 0xdf, 0xff, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x1b, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xa1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7c, 0xff, 0xff, + 0xff, 0xff, 0xd9, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x45, 0x77, 0x64, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03CD "ύ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfe, 0x2f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xe2, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfe, + 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xe2, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xfe, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xe2, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xfe, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xe2, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xfe, 0x2f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xe2, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xfe, 0x2f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xe2, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xfe, 0x2f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xe2, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfe, 0x2f, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xe2, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfe, 0x2f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xe1, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfd, + 0x1f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xc0, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xfb, 0xd, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0x70, 0xaf, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xf4, 0x5, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfe, 0x0, 0xe, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0x80, 0x0, 0x6f, 0xff, 0xff, 0xfa, + 0x20, 0x0, 0x4, 0xcf, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xff, 0xec, 0xce, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x18, 0xef, 0xff, 0xff, 0xff, 0xfb, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x25, 0x67, + 0x75, 0x40, 0x0, 0x0, 0x0, 0x0, + + /* U+03CE "ώ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0x20, 0x0, 0x4, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf8, + 0x0, 0x0, 0xaf, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xe0, 0x0, 0xf, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0x40, 0x5, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x67, 0x77, 0x71, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf9, 0x0, 0x9f, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xe0, 0xd, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x20, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xf5, 0x3f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0x85, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xfa, 0x7f, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xc8, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfc, 0x8f, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xc7, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfc, 0x6f, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xb5, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfa, + 0x3f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0x70, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xf4, 0xc, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0x10, 0x7f, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xc0, 0x1, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xf6, 0x0, 0xb, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x1d, 0xff, + 0xf5, 0xef, 0xff, 0x40, 0x0, 0x0, 0x1, 0xdf, + 0xff, 0xff, 0x10, 0x0, 0x2f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x3e, 0xff, 0xfc, 0x7, 0xff, 0xff, + 0x60, 0x0, 0x2, 0xdf, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xfd, 0x99, 0xcf, 0xff, + 0xff, 0x20, 0xd, 0xff, 0xff, 0xe9, 0x9b, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x2e, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc1, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x2d, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xa1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3b, 0xff, 0xff, 0xff, 0xfa, 0x20, 0x0, 0x0, + 0x0, 0x8, 0xef, 0xff, 0xff, 0xfc, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x57, 0x76, + 0x41, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x36, + 0x76, 0x51, 0x0, 0x0, 0x0, 0x0, + + /* U+03F4 "ϴ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x47, 0x77, 0x72, + 0x0, 0x5, 0xff, 0xff, 0x50, 0x77, 0x77, 0x7a, + 0xff, 0xff, 0x40, 0x0, 0xcf, 0xff, 0x90, 0xf, + 0xff, 0xff, 0xaf, 0xff, 0xf4, 0x0, 0x4f, 0xff, + 0xd0, 0x0, 0xff, 0xff, 0xfa, 0xff, 0xff, 0x40, + 0xb, 0xff, 0xf3, 0x0, 0xf, 0xff, 0xff, 0xaf, + 0xff, 0xf4, 0x2, 0xff, 0xf7, 0x0, 0x0, 0xff, + 0xff, 0xfa, 0xff, 0xff, 0x40, 0xaf, 0xfc, 0x0, + 0x0, 0xf, 0xff, 0xff +}; + + +/*--------------------- + * GLYPH DESCRIPTION + *--------------------*/ + +static const lv_font_fmt_txt_glyph_dsc_t glyph_dsc[] = { + {.bitmap_index = 0, .adv_w = 0, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0} /* id = 0 reserved */, + {.bitmap_index = 0, .adv_w = 258, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 0, .adv_w = 259, .box_w = 8, .box_h = 42, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 168, .adv_w = 329, .box_w = 16, .box_h = 15, .ofs_x = 2, .ofs_y = 27}, + {.bitmap_index = 288, .adv_w = 516, .box_w = 32, .box_h = 45, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 1008, .adv_w = 516, .box_w = 28, .box_h = 52, .ofs_x = 2, .ofs_y = -6}, + {.bitmap_index = 1736, .adv_w = 825, .box_w = 46, .box_h = 45, .ofs_x = 3, .ofs_y = -2}, + {.bitmap_index = 2771, .adv_w = 619, .box_w = 36, .box_h = 44, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 3563, .adv_w = 176, .box_w = 7, .box_h = 15, .ofs_x = 2, .ofs_y = 27}, + {.bitmap_index = 3616, .adv_w = 309, .box_w = 15, .box_h = 55, .ofs_x = 3, .ofs_y = -12}, + {.bitmap_index = 4029, .adv_w = 309, .box_w = 14, .box_h = 55, .ofs_x = 2, .ofs_y = -12}, + {.bitmap_index = 4414, .adv_w = 361, .box_w = 20, .box_h = 18, .ofs_x = 1, .ofs_y = 25}, + {.bitmap_index = 4594, .adv_w = 542, .box_w = 28, .box_h = 28, .ofs_x = 3, .ofs_y = 7}, + {.bitmap_index = 4986, .adv_w = 259, .box_w = 7, .box_h = 15, .ofs_x = 4, .ofs_y = -9}, + {.bitmap_index = 5039, .adv_w = 309, .box_w = 17, .box_h = 6, .ofs_x = 1, .ofs_y = 13}, + {.bitmap_index = 5090, .adv_w = 259, .box_w = 6, .box_h = 6, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 5108, .adv_w = 258, .box_w = 17, .box_h = 44, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 5482, .adv_w = 516, .box_w = 28, .box_h = 43, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 6084, .adv_w = 516, .box_w = 16, .box_h = 42, .ofs_x = 6, .ofs_y = 0}, + {.bitmap_index = 6420, .adv_w = 516, .box_w = 29, .box_h = 42, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 7029, .adv_w = 516, .box_w = 28, .box_h = 43, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 7631, .adv_w = 516, .box_w = 30, .box_h = 42, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 8261, .adv_w = 516, .box_w = 29, .box_h = 43, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 8885, .adv_w = 516, .box_w = 28, .box_h = 43, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 9487, .adv_w = 516, .box_w = 28, .box_h = 41, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 10061, .adv_w = 516, .box_w = 28, .box_h = 43, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 10663, .adv_w = 516, .box_w = 28, .box_h = 43, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 11265, .adv_w = 259, .box_w = 6, .box_h = 30, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 11355, .adv_w = 259, .box_w = 7, .box_h = 39, .ofs_x = 4, .ofs_y = -9}, + {.bitmap_index = 11492, .adv_w = 542, .box_w = 28, .box_h = 29, .ofs_x = 3, .ofs_y = 6}, + {.bitmap_index = 11898, .adv_w = 542, .box_w = 28, .box_h = 18, .ofs_x = 3, .ofs_y = 12}, + {.bitmap_index = 12150, .adv_w = 542, .box_w = 28, .box_h = 29, .ofs_x = 3, .ofs_y = 6}, + {.bitmap_index = 12556, .adv_w = 516, .box_w = 28, .box_h = 43, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 13158, .adv_w = 942, .box_w = 54, .box_h = 56, .ofs_x = 3, .ofs_y = -13}, + {.bitmap_index = 14670, .adv_w = 619, .box_w = 40, .box_h = 42, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 15510, .adv_w = 619, .box_w = 32, .box_h = 42, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 16182, .adv_w = 670, .box_w = 38, .box_h = 44, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 17018, .adv_w = 670, .box_w = 35, .box_h = 42, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 17753, .adv_w = 619, .box_w = 32, .box_h = 42, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 18425, .adv_w = 568, .box_w = 29, .box_h = 42, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 19034, .adv_w = 722, .box_w = 39, .box_h = 44, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 19892, .adv_w = 670, .box_w = 34, .box_h = 42, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 20606, .adv_w = 259, .box_w = 6, .box_h = 42, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 20732, .adv_w = 464, .box_w = 24, .box_h = 43, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 21248, .adv_w = 619, .box_w = 35, .box_h = 42, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 21983, .adv_w = 516, .box_w = 27, .box_h = 42, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 22550, .adv_w = 773, .box_w = 40, .box_h = 42, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 23390, .adv_w = 670, .box_w = 34, .box_h = 42, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 24104, .adv_w = 722, .box_w = 41, .box_h = 44, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 25006, .adv_w = 619, .box_w = 33, .box_h = 42, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 25699, .adv_w = 722, .box_w = 42, .box_h = 47, .ofs_x = 2, .ofs_y = -4}, + {.bitmap_index = 26686, .adv_w = 670, .box_w = 38, .box_h = 42, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 27484, .adv_w = 619, .box_w = 34, .box_h = 44, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 28232, .adv_w = 568, .box_w = 34, .box_h = 42, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 28946, .adv_w = 670, .box_w = 34, .box_h = 43, .ofs_x = 4, .ofs_y = -1}, + {.bitmap_index = 29677, .adv_w = 619, .box_w = 39, .box_h = 42, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 30496, .adv_w = 876, .box_w = 54, .box_h = 42, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 31630, .adv_w = 619, .box_w = 39, .box_h = 42, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 32449, .adv_w = 619, .box_w = 39, .box_h = 42, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 33268, .adv_w = 568, .box_w = 33, .box_h = 42, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 33961, .adv_w = 259, .box_w = 13, .box_h = 54, .ofs_x = 3, .ofs_y = -12}, + {.bitmap_index = 34312, .adv_w = 258, .box_w = 17, .box_h = 44, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 34686, .adv_w = 259, .box_w = 12, .box_h = 54, .ofs_x = 1, .ofs_y = -12}, + {.bitmap_index = 35010, .adv_w = 435, .box_w = 25, .box_h = 23, .ofs_x = 1, .ofs_y = 20}, + {.bitmap_index = 35298, .adv_w = 516, .box_w = 34, .box_h = 4, .ofs_x = -1, .ofs_y = -12}, + {.bitmap_index = 35366, .adv_w = 309, .box_w = 12, .box_h = 8, .ofs_x = 2, .ofs_y = 34}, + {.bitmap_index = 35414, .adv_w = 516, .box_w = 28, .box_h = 32, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 35862, .adv_w = 516, .box_w = 27, .box_h = 43, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 36443, .adv_w = 464, .box_w = 27, .box_h = 32, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 36875, .adv_w = 516, .box_w = 27, .box_h = 43, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 37456, .adv_w = 516, .box_w = 28, .box_h = 32, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 37904, .adv_w = 259, .box_w = 19, .box_h = 43, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 38313, .adv_w = 516, .box_w = 28, .box_h = 44, .ofs_x = 1, .ofs_y = -13}, + {.bitmap_index = 38929, .adv_w = 516, .box_w = 26, .box_h = 42, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 39475, .adv_w = 206, .box_w = 6, .box_h = 42, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 39601, .adv_w = 206, .box_w = 12, .box_h = 55, .ofs_x = -3, .ofs_y = -13}, + {.bitmap_index = 39931, .adv_w = 464, .box_w = 26, .box_h = 42, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 40477, .adv_w = 206, .box_w = 6, .box_h = 42, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 40603, .adv_w = 773, .box_w = 42, .box_h = 31, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 41254, .adv_w = 516, .box_w = 26, .box_h = 31, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 41657, .adv_w = 516, .box_w = 29, .box_h = 32, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 42121, .adv_w = 516, .box_w = 28, .box_h = 43, .ofs_x = 3, .ofs_y = -12}, + {.bitmap_index = 42723, .adv_w = 516, .box_w = 27, .box_h = 43, .ofs_x = 2, .ofs_y = -12}, + {.bitmap_index = 43304, .adv_w = 309, .box_w = 18, .box_h = 31, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 43583, .adv_w = 464, .box_w = 26, .box_h = 32, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 43999, .adv_w = 259, .box_w = 16, .box_h = 42, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 44335, .adv_w = 516, .box_w = 26, .box_h = 31, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 44738, .adv_w = 464, .box_w = 29, .box_h = 30, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 45173, .adv_w = 670, .box_w = 42, .box_h = 30, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 45803, .adv_w = 464, .box_w = 29, .box_h = 30, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 46238, .adv_w = 464, .box_w = 29, .box_h = 43, .ofs_x = 0, .ofs_y = -13}, + {.bitmap_index = 46862, .adv_w = 464, .box_w = 27, .box_h = 30, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 47267, .adv_w = 309, .box_w = 18, .box_h = 56, .ofs_x = 1, .ofs_y = -13}, + {.bitmap_index = 47771, .adv_w = 241, .box_w = 5, .box_h = 55, .ofs_x = 5, .ofs_y = -12}, + {.bitmap_index = 47909, .adv_w = 309, .box_w = 17, .box_h = 56, .ofs_x = 1, .ofs_y = -13}, + {.bitmap_index = 48385, .adv_w = 542, .box_w = 30, .box_h = 11, .ofs_x = 2, .ofs_y = 15}, + {.bitmap_index = 48550, .adv_w = 258, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 48550, .adv_w = 516, .box_w = 31, .box_h = 44, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 49232, .adv_w = 516, .box_w = 29, .box_h = 28, .ofs_x = 2, .ofs_y = 7}, + {.bitmap_index = 49638, .adv_w = 516, .box_w = 33, .box_h = 42, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 50331, .adv_w = 242, .box_w = 5, .box_h = 55, .ofs_x = 5, .ofs_y = -12}, + {.bitmap_index = 50469, .adv_w = 516, .box_w = 28, .box_h = 56, .ofs_x = 2, .ofs_y = -13}, + {.bitmap_index = 51253, .adv_w = 309, .box_w = 17, .box_h = 6, .ofs_x = 1, .ofs_y = 36}, + {.bitmap_index = 51304, .adv_w = 684, .box_w = 43, .box_h = 43, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 52229, .adv_w = 348, .box_w = 21, .box_h = 21, .ofs_x = 0, .ofs_y = 21}, + {.bitmap_index = 52450, .adv_w = 516, .box_w = 26, .box_h = 27, .ofs_x = 3, .ofs_y = 2}, + {.bitmap_index = 52801, .adv_w = 542, .box_w = 28, .box_h = 18, .ofs_x = 3, .ofs_y = 12}, + {.bitmap_index = 53053, .adv_w = 309, .box_w = 17, .box_h = 6, .ofs_x = 1, .ofs_y = 13}, + {.bitmap_index = 53104, .adv_w = 684, .box_w = 43, .box_h = 43, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 54029, .adv_w = 371, .box_w = 17, .box_h = 16, .ofs_x = 3, .ofs_y = 27}, + {.bitmap_index = 54165, .adv_w = 542, .box_w = 28, .box_h = 35, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 54655, .adv_w = 309, .box_w = 19, .box_h = 21, .ofs_x = 0, .ofs_y = 21}, + {.bitmap_index = 54855, .adv_w = 309, .box_w = 19, .box_h = 22, .ofs_x = 0, .ofs_y = 20}, + {.bitmap_index = 55064, .adv_w = 516, .box_w = 26, .box_h = 42, .ofs_x = 3, .ofs_y = -12}, + {.bitmap_index = 55610, .adv_w = 498, .box_w = 33, .box_h = 54, .ofs_x = -1, .ofs_y = -12}, + {.bitmap_index = 56501, .adv_w = 260, .box_w = 7, .box_h = 6, .ofs_x = 5, .ofs_y = 18}, + {.bitmap_index = 56522, .adv_w = 516, .box_w = 25, .box_h = 27, .ofs_x = 4, .ofs_y = 2}, + {.bitmap_index = 56860, .adv_w = 774, .box_w = 45, .box_h = 45, .ofs_x = 3, .ofs_y = -2}, + {.bitmap_index = 57873, .adv_w = 309, .box_w = 11, .box_h = 8, .ofs_x = 6, .ofs_y = 35}, + {.bitmap_index = 57917, .adv_w = 619, .box_w = 40, .box_h = 42, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 58757, .adv_w = 728, .box_w = 46, .box_h = 42, .ofs_x = -3, .ofs_y = 0}, + {.bitmap_index = 59723, .adv_w = 778, .box_w = 46, .box_h = 42, .ofs_x = -3, .ofs_y = 0}, + {.bitmap_index = 60689, .adv_w = 356, .box_w = 19, .box_h = 42, .ofs_x = -3, .ofs_y = 0}, + {.bitmap_index = 61088, .adv_w = 719, .box_w = 46, .box_h = 44, .ofs_x = -3, .ofs_y = -1}, + {.bitmap_index = 62100, .adv_w = 794, .box_w = 52, .box_h = 42, .ofs_x = -3, .ofs_y = 0}, + {.bitmap_index = 63192, .adv_w = 698, .box_w = 44, .box_h = 43, .ofs_x = -3, .ofs_y = 0}, + {.bitmap_index = 64138, .adv_w = 206, .box_w = 21, .box_h = 43, .ofs_x = -4, .ofs_y = 0}, + {.bitmap_index = 64590, .adv_w = 619, .box_w = 40, .box_h = 42, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 65430, .adv_w = 619, .box_w = 32, .box_h = 42, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 66102, .adv_w = 511, .box_w = 27, .box_h = 42, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 66669, .adv_w = 620, .box_w = 40, .box_h = 42, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 67509, .adv_w = 619, .box_w = 32, .box_h = 42, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 68181, .adv_w = 568, .box_w = 33, .box_h = 42, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 68874, .adv_w = 670, .box_w = 34, .box_h = 42, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 69588, .adv_w = 722, .box_w = 41, .box_h = 44, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 70490, .adv_w = 259, .box_w = 6, .box_h = 42, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 70616, .adv_w = 619, .box_w = 35, .box_h = 42, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 71351, .adv_w = 620, .box_w = 39, .box_h = 42, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 72170, .adv_w = 773, .box_w = 40, .box_h = 42, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 73010, .adv_w = 670, .box_w = 34, .box_h = 42, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 73724, .adv_w = 603, .box_w = 32, .box_h = 42, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 74396, .adv_w = 722, .box_w = 41, .box_h = 44, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 75298, .adv_w = 670, .box_w = 34, .box_h = 42, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 76012, .adv_w = 619, .box_w = 33, .box_h = 42, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 76705, .adv_w = 574, .box_w = 30, .box_h = 42, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 77335, .adv_w = 568, .box_w = 34, .box_h = 42, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 78049, .adv_w = 619, .box_w = 39, .box_h = 42, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 78868, .adv_w = 740, .box_w = 42, .box_h = 45, .ofs_x = 2, .ofs_y = -2}, + {.bitmap_index = 79813, .adv_w = 619, .box_w = 39, .box_h = 42, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 80632, .adv_w = 775, .box_w = 42, .box_h = 42, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 81514, .adv_w = 694, .box_w = 39, .box_h = 43, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 82353, .adv_w = 259, .box_w = 17, .box_h = 50, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 82778, .adv_w = 619, .box_w = 39, .box_h = 50, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 83753, .adv_w = 537, .box_w = 30, .box_h = 44, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 84413, .adv_w = 414, .box_w = 23, .box_h = 44, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 84919, .adv_w = 516, .box_w = 26, .box_h = 55, .ofs_x = 3, .ofs_y = -12}, + {.bitmap_index = 85634, .adv_w = 206, .box_w = 11, .box_h = 43, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 85871, .adv_w = 508, .box_w = 25, .box_h = 44, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 86421, .adv_w = 537, .box_w = 30, .box_h = 32, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 86901, .adv_w = 534, .box_w = 28, .box_h = 55, .ofs_x = 3, .ofs_y = -12}, + {.bitmap_index = 87671, .adv_w = 464, .box_w = 29, .box_h = 42, .ofs_x = 0, .ofs_y = -12}, + {.bitmap_index = 88280, .adv_w = 517, .box_w = 29, .box_h = 43, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 88904, .adv_w = 414, .box_w = 23, .box_h = 32, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 89272, .adv_w = 409, .box_w = 24, .box_h = 55, .ofs_x = 2, .ofs_y = -13}, + {.bitmap_index = 89932, .adv_w = 516, .box_w = 26, .box_h = 43, .ofs_x = 3, .ofs_y = -12}, + {.bitmap_index = 90491, .adv_w = 516, .box_w = 28, .box_h = 44, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 91107, .adv_w = 206, .box_w = 6, .box_h = 30, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 91197, .adv_w = 462, .box_w = 26, .box_h = 30, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 91587, .adv_w = 464, .box_w = 29, .box_h = 42, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 92196, .adv_w = 516, .box_w = 26, .box_h = 42, .ofs_x = 3, .ofs_y = -12}, + {.bitmap_index = 92742, .adv_w = 464, .box_w = 29, .box_h = 30, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 93177, .adv_w = 416, .box_w = 23, .box_h = 55, .ofs_x = 2, .ofs_y = -12}, + {.bitmap_index = 93810, .adv_w = 516, .box_w = 29, .box_h = 32, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 94274, .adv_w = 640, .box_w = 38, .box_h = 30, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 94844, .adv_w = 528, .box_w = 28, .box_h = 43, .ofs_x = 3, .ofs_y = -12}, + {.bitmap_index = 95446, .adv_w = 447, .box_w = 26, .box_h = 44, .ofs_x = 2, .ofs_y = -13}, + {.bitmap_index = 96018, .adv_w = 573, .box_w = 34, .box_h = 32, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 96562, .adv_w = 367, .box_w = 21, .box_h = 30, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 96877, .adv_w = 508, .box_w = 25, .box_h = 31, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 97265, .adv_w = 602, .box_w = 34, .box_h = 43, .ofs_x = 2, .ofs_y = -12}, + {.bitmap_index = 97996, .adv_w = 487, .box_w = 30, .box_h = 42, .ofs_x = 0, .ofs_y = -12}, + {.bitmap_index = 98626, .adv_w = 662, .box_w = 35, .box_h = 42, .ofs_x = 3, .ofs_y = -12}, + {.bitmap_index = 99361, .adv_w = 725, .box_w = 41, .box_h = 31, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 99997, .adv_w = 206, .box_w = 17, .box_h = 42, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 100354, .adv_w = 508, .box_w = 25, .box_h = 43, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 100892, .adv_w = 516, .box_w = 29, .box_h = 44, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 101530, .adv_w = 508, .box_w = 25, .box_h = 44, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 102080, .adv_w = 725, .box_w = 41, .box_h = 44, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 102982, .adv_w = 309, .box_w = 21, .box_h = 8, .ofs_x = -1, .ofs_y = 35} +}; + +/*--------------------- + * CHARACTER MAPPING + *--------------------*/ + +static const uint8_t glyph_id_ofs_list_1[] = { + 0, 0, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 0, + 13, 14, 15, 16, 0, 17, 18, 19, + 0, 0, 0, 20, 0, 21 +}; + +static const uint8_t glyph_id_ofs_list_2[] = { + 0, 0, 1, 0, 2, 3, 4, 0, + 5 +}; + +/*Collect the unicode lists and glyph_id offsets*/ +static const lv_font_fmt_txt_cmap_t cmaps[] = +{ + { + .range_start = 32, .range_length = 95, .glyph_id_start = 1, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 160, .range_length = 30, .glyph_id_start = 96, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_1, .list_length = 30, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 900, .range_length = 9, .glyph_id_start = 118, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_2, .list_length = 9, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 910, .range_length = 20, .glyph_id_start = 124, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 931, .range_length = 44, .glyph_id_start = 144, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 1012, .range_length = 1, .glyph_id_start = 188, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + } +}; + + + +/*-------------------- + * ALL CUSTOM DATA + *--------------------*/ + +#if LVGL_VERSION_MAJOR == 8 +/*Store all the custom data of the font*/ +static lv_font_fmt_txt_glyph_cache_t cache; +#endif + +#if LVGL_VERSION_MAJOR >= 8 +static const lv_font_fmt_txt_dsc_t font_dsc = { +#else +static lv_font_fmt_txt_dsc_t font_dsc = { +#endif + .glyph_bitmap = glyph_bitmap, + .glyph_dsc = glyph_dsc, + .cmaps = cmaps, + .kern_dsc = NULL, + .kern_scale = 0, + .cmap_num = 6, + .bpp = 4, + .kern_classes = 0, + .bitmap_format = 0, +#if LVGL_VERSION_MAJOR == 8 + .cache = &cache +#endif + +}; + +extern const lv_font_t lv_font_montserrat_48; + + +/*----------------- + * PUBLIC FONT + *----------------*/ + +/*Initialize a public general font descriptor*/ +#if LVGL_VERSION_MAJOR >= 8 +const lv_font_t lv_font_arial_58 = { +#else +lv_font_t lv_font_arial_58 = { +#endif + .get_glyph_dsc = lv_font_get_glyph_dsc_fmt_txt, /*Function pointer to get glyph's data*/ + .get_glyph_bitmap = lv_font_get_bitmap_fmt_txt, /*Function pointer to get glyph's bitmap*/ + .line_height = 63, /*The maximum line height required by the font*/ + .base_line = 13, /*Baseline measured from the bottom of the line*/ +#if !(LVGL_VERSION_MAJOR == 6 && LVGL_VERSION_MINOR == 0) + .subpx = LV_FONT_SUBPX_NONE, +#endif +#if LV_VERSION_CHECK(7, 4, 0) || LVGL_VERSION_MAJOR >= 8 + .underline_position = -6, + .underline_thickness = 4, +#endif + //.static_bitmap = 0, + .dsc = &font_dsc, /*The custom font data. Will be accessed by `get_glyph_bitmap/dsc` */ +#if LV_VERSION_CHECK(8, 2, 0) || LVGL_VERSION_MAJOR >= 9 + .fallback = &lv_font_montserrat_48, +#endif + .user_data = NULL, +}; + + + +#endif /*#if LV_FONT_ARIAL_58*/ diff --git a/src/fonts/lv_font_arial_66.c b/src/fonts/lv_font_arial_66.c new file mode 100644 index 0000000000..f385da6356 --- /dev/null +++ b/src/fonts/lv_font_arial_66.c @@ -0,0 +1,17268 @@ +/******************************************************************************* + * Size: 66 px + * Bpp: 4 + * Opts: --bpp 4 --size 66 --no-compress --stride 1 --align 1 --font Arial Greek Regular.ttf --range 32-127,160-255,880-1023 --format lvgl -o lv_font_arial_66.c + ******************************************************************************/ + +#ifdef __has_include + #if __has_include("lvgl.h") + #ifndef LV_LVGL_H_INCLUDE_SIMPLE + #define LV_LVGL_H_INCLUDE_SIMPLE + #endif + #endif +#endif + +#ifdef LV_LVGL_H_INCLUDE_SIMPLE + #include "lvgl.h" +#else + #include "lvgl/lvgl.h" +#endif + + + +#ifndef LV_FONT_ARIAL_66 +#define LV_FONT_ARIAL_66 1 +#endif + +#if LV_FONT_ARIAL_66 + +/*----------------- + * BITMAPS + *----------------*/ + +/*Store the image of the glyphs*/ +static LV_ATTRIBUTE_LARGE_CONST const uint8_t glyph_bitmap[] = { + /* U+0020 " " */ + + /* U+0021 "!" */ + 0x6f, 0xff, 0xff, 0xfc, 0x6f, 0xff, 0xff, 0xfc, + 0x6f, 0xff, 0xff, 0xfc, 0x6f, 0xff, 0xff, 0xfc, + 0x6f, 0xff, 0xff, 0xfc, 0x6f, 0xff, 0xff, 0xfc, + 0x6f, 0xff, 0xff, 0xfc, 0x6f, 0xff, 0xff, 0xfc, + 0x6f, 0xff, 0xff, 0xfc, 0x6f, 0xff, 0xff, 0xfc, + 0x6f, 0xff, 0xff, 0xfc, 0x5f, 0xff, 0xff, 0xfb, + 0x4f, 0xff, 0xff, 0xfa, 0x3f, 0xff, 0xff, 0xf8, + 0x2f, 0xff, 0xff, 0xf7, 0x1f, 0xff, 0xff, 0xf6, + 0xf, 0xff, 0xff, 0xf5, 0xe, 0xff, 0xff, 0xf4, + 0xd, 0xff, 0xff, 0xf3, 0xc, 0xff, 0xff, 0xf2, + 0xb, 0xff, 0xff, 0xf1, 0xa, 0xff, 0xff, 0xf0, + 0x9, 0xff, 0xff, 0xf0, 0x8, 0xff, 0xff, 0xe0, + 0x6, 0xff, 0xff, 0xd0, 0x5, 0xff, 0xff, 0xc0, + 0x4, 0xff, 0xff, 0xb0, 0x3, 0xff, 0xff, 0xa0, + 0x2, 0xff, 0xff, 0x80, 0x1, 0xff, 0xff, 0x70, + 0x0, 0xff, 0xff, 0x60, 0x0, 0xff, 0xff, 0x50, + 0x0, 0xdf, 0xff, 0x40, 0x0, 0xcf, 0xff, 0x30, + 0x0, 0xbf, 0xff, 0x20, 0x0, 0x58, 0x88, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x19, 0x99, 0x99, 0x94, 0x2f, 0xff, 0xff, 0xf8, + 0x2f, 0xff, 0xff, 0xf8, 0x2f, 0xff, 0xff, 0xf8, + 0x2f, 0xff, 0xff, 0xf8, 0x2f, 0xff, 0xff, 0xf8, + 0x2f, 0xff, 0xff, 0xf8, + + /* U+0022 "\"" */ + 0xbb, 0xbb, 0xbb, 0x70, 0x0, 0x2b, 0xbb, 0xbb, + 0xb4, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x3f, 0xff, + 0xff, 0xf6, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x3f, + 0xff, 0xff, 0xf6, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x3f, 0xff, 0xff, 0xf6, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x3f, 0xff, 0xff, 0xf6, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x3f, 0xff, 0xff, 0xf6, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0x3f, 0xff, 0xff, 0xf6, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x3f, 0xff, 0xff, 0xf6, + 0xdf, 0xff, 0xff, 0x90, 0x0, 0x2f, 0xff, 0xff, + 0xf4, 0xaf, 0xff, 0xff, 0x60, 0x0, 0xf, 0xff, + 0xff, 0xf1, 0x7f, 0xff, 0xff, 0x40, 0x0, 0xc, + 0xff, 0xff, 0xf0, 0x5f, 0xff, 0xff, 0x10, 0x0, + 0x9, 0xff, 0xff, 0xc0, 0x2f, 0xff, 0xff, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x90, 0xf, 0xff, 0xfc, + 0x0, 0x0, 0x4, 0xff, 0xff, 0x60, 0xc, 0xff, + 0xf9, 0x0, 0x0, 0x1, 0xff, 0xff, 0x40, 0x9, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0xef, 0xff, 0x10, + 0x6, 0xff, 0xf4, 0x0, 0x0, 0x0, 0xbf, 0xfe, + 0x0, + + /* U+0023 "#" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x2c, 0xcc, 0xcc, 0xcc, + 0xce, 0xff, 0xff, 0xec, 0xcc, 0xcc, 0xcc, 0xcc, + 0xef, 0xff, 0xfe, 0xcc, 0xcc, 0xcc, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x2c, 0xcc, 0xcc, 0xcf, + 0xff, 0xff, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xff, + 0xff, 0xfc, 0xcc, 0xcc, 0xcc, 0xcc, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0x88, 0x88, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x48, 0x88, 0x82, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0024 "$" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x38, + 0x87, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x68, 0xdf, + 0xff, 0xa7, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x39, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1a, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xff, 0xff, 0xa5, 0x8f, + 0xff, 0x49, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xb1, 0x0, 0x7f, + 0xff, 0x0, 0x1b, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0xef, 0xff, 0xff, 0x20, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0x10, + 0x3, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0x40, + 0x5, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0x70, + 0x7, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0x0, 0x6b, 0x86, 0x31, 0x0, + 0x7, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0xb1, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0x93, 0x7f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xea, 0x62, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x8e, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x37, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x2, 0x8e, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xfa, + 0x2, 0x58, 0xbe, 0x60, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xfb, + 0x7f, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xfa, + 0x5f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf9, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf7, + 0xe, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf4, + 0xa, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf0, + 0x5, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xa0, + 0x0, 0xdf, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0x40, 0x0, 0x7f, + 0xff, 0x0, 0x1, 0xbf, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xfa, 0x30, 0x7f, + 0xff, 0x1, 0x7f, 0xff, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xef, + 0xff, 0xdf, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x1c, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5a, 0xdf, 0xff, + 0xff, 0xfe, 0xc9, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0025 "%" */ + 0x0, 0x0, 0x0, 0x16, 0xbd, 0xff, 0xda, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xef, 0xff, 0xff, + 0xff, 0xfd, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xc4, 0x10, 0x3b, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0x80, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x30, 0x0, + 0x0, 0xa, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xc4, 0x0, 0x3b, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x3, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xdf, 0xff, 0xff, 0xff, 0xfd, 0x30, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xad, 0xff, 0xda, 0x40, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x3, 0x8c, 0xef, 0xec, + 0x83, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x1, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xb2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x1d, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf8, 0x20, 0x16, + 0xef, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf7, 0x20, 0x16, + 0xef, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1c, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0x91, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x7c, 0xef, 0xec, + 0x82, 0x0, 0x0, 0x0, + + /* U+0026 "&" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x26, + 0x9a, 0xba, 0x96, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xb3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1b, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1d, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xb4, 0x10, + 0x28, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x2, 0xef, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x1, 0xdf, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x1, 0xcf, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0x30, 0x2, 0xdf, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xfe, 0x27, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xa1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x9f, 0xff, 0xff, 0xff, + 0xfd, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3d, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xd4, + 0x7f, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0xaf, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0xc, 0xb8, 0x51, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xfe, 0x20, 0x0, + 0x1, 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x1, 0xef, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0xb, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xf6, 0x1, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xf3, 0x8f, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xee, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xe2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xff, 0xe5, 0x0, 0x0, 0x0, 0x0, 0x5e, + 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xfc, + 0x74, 0x22, 0x48, 0xef, 0xff, 0xff, 0xff, 0xf7, + 0xc, 0xff, 0xff, 0xff, 0xfd, 0x20, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf7, 0x0, 0x1d, 0xff, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe4, + 0x0, 0x0, 0x1d, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x3d, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xa1, 0x0, 0x0, 0x0, 0x1d, + 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x30, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x38, 0xbd, 0xff, + 0xfe, 0xc9, 0x51, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, + 0x0, + + /* U+0027 "'" */ + 0xbb, 0xbb, 0xbb, 0x7f, 0xff, 0xff, 0xf9, 0xff, + 0xff, 0xff, 0x9f, 0xff, 0xff, 0xf9, 0xff, 0xff, + 0xff, 0x9f, 0xff, 0xff, 0xf9, 0xff, 0xff, 0xff, + 0x9f, 0xff, 0xff, 0xf9, 0xff, 0xff, 0xff, 0x8c, + 0xff, 0xff, 0xf5, 0x9f, 0xff, 0xff, 0x37, 0xff, + 0xff, 0xf0, 0x4f, 0xff, 0xfd, 0x1, 0xff, 0xff, + 0xa0, 0xe, 0xff, 0xf7, 0x0, 0xcf, 0xff, 0x50, + 0x9, 0xff, 0xf2, 0x0, + + /* U+0028 "(" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xf4, + + /* U+0029 ")" */ + 0x5f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+002A "*" */ + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xc7, 0x10, 0x0, 0x2f, 0xff, 0xb0, 0x0, 0x2, + 0x8e, 0x30, 0xd, 0xff, 0xfa, 0x40, 0xf, 0xff, + 0x90, 0x6, 0xdf, 0xff, 0x80, 0x2f, 0xff, 0xff, + 0xfc, 0x5e, 0xff, 0x88, 0xef, 0xff, 0xff, 0xd0, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf2, 0x6c, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xc3, 0x0, 0x4, + 0x8b, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xc9, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xfd, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xaf, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x17, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf7, 0x0, 0xdf, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xd0, 0x0, 0x4f, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x1d, 0xff, 0xff, 0x40, + 0x0, 0xa, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0xaf, 0xfa, 0x0, 0x0, 0x1, 0xef, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xd1, 0x0, 0x0, 0x0, + 0x4d, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+002B "+" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x33, + 0x33, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x26, 0x66, 0x66, 0x66, 0x66, 0x66, 0x6a, 0xff, + 0xff, 0xf6, 0x66, 0x66, 0x66, 0x66, 0x66, 0x65, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+002C "," */ + 0x29, 0x99, 0x99, 0x93, 0x4f, 0xff, 0xff, 0xf5, + 0x4f, 0xff, 0xff, 0xf5, 0x4f, 0xff, 0xff, 0xf5, + 0x4f, 0xff, 0xff, 0xf5, 0x4f, 0xff, 0xff, 0xf5, + 0x4f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0xff, 0xf5, + 0x0, 0x2, 0xff, 0xf4, 0x0, 0x4, 0xff, 0xf1, + 0x0, 0x9, 0xff, 0xe0, 0x0, 0x1e, 0xff, 0x90, + 0x0, 0xcf, 0xff, 0x20, 0x3d, 0xff, 0xf8, 0x0, + 0x3f, 0xff, 0xa0, 0x0, 0x9, 0xf7, 0x0, 0x0, + 0x0, 0x10, 0x0, 0x0, + + /* U+002D "-" */ + 0xcd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdc, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + + /* U+002E "." */ + 0x19, 0x99, 0x99, 0x94, 0x2f, 0xff, 0xff, 0xf7, + 0x2f, 0xff, 0xff, 0xf7, 0x2f, 0xff, 0xff, 0xf7, + 0x2f, 0xff, 0xff, 0xf7, 0x2f, 0xff, 0xff, 0xf7, + 0x2f, 0xff, 0xff, 0xf7, + + /* U+002F "/" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0030 "0" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x9c, 0xef, + 0xfe, 0xda, 0x72, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0xde, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0xb4, 0x0, + 0x0, 0x17, 0xef, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x1c, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x30, + 0x0, 0xef, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x70, + 0x2, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xb0, + 0x5, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xe0, + 0x8, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf1, + 0xa, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf3, + 0xc, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf5, + 0xe, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf6, + 0xf, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf8, + 0xf, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf9, + 0x1f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf9, + 0x1f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf9, + 0xf, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf9, + 0xf, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf8, + 0xe, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf6, + 0xc, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf5, + 0xa, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf3, + 0x8, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf1, + 0x5, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xe0, + 0x2, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xb0, + 0x0, 0xef, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x70, + 0x0, 0xaf, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x30, + 0x0, 0x5f, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x1c, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0xc4, 0x0, + 0x0, 0x17, 0xef, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0xce, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x9c, 0xef, + 0xff, 0xda, 0x72, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0031 "1" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x77, + 0x75, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x3d, 0xff, 0xff, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x0, 0x4, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x3, 0xbf, 0xff, 0xff, 0xff, + 0xf7, 0xff, 0xff, 0xfb, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0x41, 0xff, 0xff, 0xfb, 0xbf, 0xff, 0xff, + 0xff, 0xc2, 0x1, 0xff, 0xff, 0xfb, 0xbf, 0xff, + 0xff, 0xf7, 0x0, 0x1, 0xff, 0xff, 0xfb, 0xbf, + 0xff, 0xfa, 0x10, 0x0, 0x1, 0xff, 0xff, 0xfb, + 0xbf, 0xfa, 0x20, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xfb, 0x98, 0x10, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfb, + + /* U+0032 "2" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x59, 0xab, + 0xcb, 0xa9, 0x51, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x17, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x1d, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, 0xb6, 0x21, + 0x1, 0x37, 0xdf, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xd3, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3e, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0x40, + 0x0, 0xef, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x90, + 0x4, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xe0, + 0x7, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf0, + 0x9, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf2, + 0xc, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf3, + 0x0, 0x13, 0x46, 0x81, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1b, 0xff, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xdf, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0xfe, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, + 0xd2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xfc, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0xa9, 0x99, 0x99, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x92, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + + /* U+0033 "3" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x26, 0xad, 0xef, + 0xed, 0xc8, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4b, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x81, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1a, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, 0xff, 0xdc, + 0xde, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xfc, 0x51, 0x0, + 0x0, 0x39, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x3d, 0xff, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xdf, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf3, 0x0, + 0x2, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf5, 0x0, + 0x6, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x36, 0x8b, 0xe6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4e, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4b, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0x78, + 0xae, 0xff, 0xff, 0xff, 0xfe, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xa1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x56, 0x31, + 0x1, 0x37, 0xdf, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3e, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xfd, + 0x7, 0x9b, 0xdf, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xfc, + 0xf, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfa, + 0xc, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf7, + 0x8, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf3, + 0x3, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xe0, + 0x0, 0xdf, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x4f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xff, 0xfe, 0x72, 0x0, + 0x0, 0x27, 0xef, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xed, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1b, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x26, 0xad, 0xef, + 0xfe, 0xda, 0x61, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0034 "4" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x24, 0x44, 0x41, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0x88, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfd, 0x8, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf3, 0x8, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x70, + 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfc, + 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xf2, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0x60, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xfb, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xe1, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xe5, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x5a, 0xff, 0xff, 0xf7, 0x55, 0x55, 0x53, + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfa, 0xf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0xf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + + /* U+0035 "5" */ + 0x0, 0x0, 0x0, 0x48, 0x88, 0x88, 0x88, 0x88, + 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x11, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf0, 0x0, 0x38, 0xcf, + 0xff, 0xff, 0xd9, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xfd, 0x4, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xcb, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x10, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x30, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, + 0xe8, 0x41, 0x0, 0x24, 0x9e, 0xff, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfe, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0xef, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x13, 0x57, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xf0, 0x3, 0x56, 0x79, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xfe, 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xa0, 0xd, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xf6, 0x0, 0xaf, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0x10, 0x5, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xa0, 0x0, 0xe, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0xfb, 0x10, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0xfe, 0x82, 0x0, 0x0, 0x16, 0xdf, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0xdd, 0xef, 0xff, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4b, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x6a, 0xce, 0xff, + 0xfd, 0xb7, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0036 "6" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x38, 0xbd, + 0xff, 0xed, 0xb8, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6d, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2d, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, + 0xdc, 0xdf, 0xff, 0xff, 0xff, 0xfe, 0x20, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xf9, 0x30, + 0x0, 0x0, 0x5d, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0xfd, 0x30, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xd1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x50, + 0x0, 0xa, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xa0, + 0x0, 0x1f, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xd0, + 0x0, 0x7f, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xd0, + 0x0, 0xbf, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x31, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x16, 0xbe, + 0xff, 0xff, 0xea, 0x60, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xc0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xa0, 0x3, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x30, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xa0, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x94, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x3f, 0xff, 0xff, 0xae, 0xff, 0xff, 0xf9, 0x42, + 0x1, 0x26, 0xbf, 0xff, 0xff, 0xff, 0xe1, 0x0, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x10, 0x0, + 0x0, 0x0, 0x4, 0xdf, 0xff, 0xff, 0xfa, 0x0, + 0x4f, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xff, 0x30, + 0x4f, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xa0, + 0x3f, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf1, + 0x3f, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, + 0x2f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf9, + 0x1f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xfb, + 0xf, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xfd, + 0xe, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfe, + 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfe, + 0x9, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfd, + 0x6, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xfb, + 0x2, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf9, + 0x0, 0xef, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf5, + 0x0, 0x9f, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf1, + 0x0, 0x3f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xc0, + 0x0, 0xc, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xfb, 0x10, 0x0, + 0x0, 0x0, 0x2, 0xcf, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xe8, 0x20, + 0x0, 0x2, 0x8f, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x1, 0xdf, 0xff, 0xff, 0xff, 0xfe, + 0xdd, 0xef, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1b, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x59, 0xce, + 0xff, 0xfd, 0xb7, 0x20, 0x0, 0x0, 0x0, 0x0, + + /* U+0037 "7" */ + 0x69, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x7c, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdc, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xdc, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+0038 "8" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x8c, 0xdf, + 0xfe, 0xda, 0x72, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x18, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0xcd, 0xff, 0xff, 0xff, 0xff, 0xe2, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xb4, 0x0, + 0x0, 0x16, 0xef, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xe4, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, 0xa3, 0x0, + 0x0, 0x4, 0xcf, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xef, 0xff, 0xff, 0xff, 0xec, + 0xcd, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x19, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x18, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xe3, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xa6, 0x21, + 0x1, 0x48, 0xef, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xc2, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3e, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0x70, + 0x3, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xe0, + 0x9, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf4, + 0xd, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf8, + 0xf, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xfc, + 0x2f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfd, + 0x3f, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfe, + 0x2f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfe, + 0x1f, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xfd, + 0xf, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xfa, + 0xb, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf7, + 0x7, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf2, + 0x1, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xc0, + 0x0, 0x9f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x1e, 0xff, 0xff, 0xff, 0xb1, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xcf, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, 0x83, 0x0, + 0x0, 0x4, 0x9f, 0xff, 0xff, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0xcd, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x20, 0x0, + 0x0, 0x0, 0x3, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xb1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1a, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3a, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe8, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x15, 0x9c, 0xde, + 0xfe, 0xdb, 0x84, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0039 "9" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x27, 0xbd, 0xff, + 0xfe, 0xb8, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1b, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0xde, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xb5, 0x0, + 0x0, 0x16, 0xdf, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xe5, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf7, 0x0, + 0x1, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xfe, 0x0, + 0x5, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x40, + 0x9, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x90, + 0xd, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xd0, + 0xf, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf1, + 0xf, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf4, + 0x1f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf6, + 0x1f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf9, + 0xf, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xfa, + 0xe, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfc, + 0xc, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xfd, + 0x8, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xfe, + 0x3, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xfe, + 0x0, 0xdf, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xfe, + 0x0, 0x6f, 0xff, 0xff, 0xfc, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xfe, + 0x0, 0xd, 0xff, 0xff, 0xff, 0xe4, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0xc6, 0x21, + 0x1, 0x38, 0xef, 0xff, 0xfb, 0xdf, 0xff, 0xfe, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd1, 0xdf, 0xff, 0xfd, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x10, 0xef, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x4e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x1, 0x9f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd4, 0x0, 0x0, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x7b, 0xef, 0xff, + 0xfd, 0x94, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x11, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x1, 0x31, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x70, + 0x2, 0xde, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x20, + 0x0, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xf8, 0x20, 0x0, + 0x1, 0x5c, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xfe, 0xdc, + 0xef, 0xff, 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x59, 0xce, 0xff, + 0xed, 0xa6, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+003A ":" */ + 0x2f, 0xff, 0xff, 0xf7, 0x2f, 0xff, 0xff, 0xf7, + 0x2f, 0xff, 0xff, 0xf7, 0x2f, 0xff, 0xff, 0xf7, + 0x2f, 0xff, 0xff, 0xf7, 0x2f, 0xff, 0xff, 0xf7, + 0x19, 0x99, 0x99, 0x94, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x19, 0x99, 0x99, 0x94, + 0x2f, 0xff, 0xff, 0xf7, 0x2f, 0xff, 0xff, 0xf7, + 0x2f, 0xff, 0xff, 0xf7, 0x2f, 0xff, 0xff, 0xf7, + 0x2f, 0xff, 0xff, 0xf7, 0x2f, 0xff, 0xff, 0xf7, + + /* U+003B ";" */ + 0x4f, 0xff, 0xff, 0xf5, 0x4f, 0xff, 0xff, 0xf5, + 0x4f, 0xff, 0xff, 0xf5, 0x4f, 0xff, 0xff, 0xf5, + 0x4f, 0xff, 0xff, 0xf5, 0x4f, 0xff, 0xff, 0xf5, + 0x29, 0x99, 0x99, 0x93, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x29, 0x99, 0x99, 0x93, + 0x4f, 0xff, 0xff, 0xf5, 0x4f, 0xff, 0xff, 0xf5, + 0x4f, 0xff, 0xff, 0xf5, 0x4f, 0xff, 0xff, 0xf5, + 0x4f, 0xff, 0xff, 0xf5, 0x4f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0xff, 0xf5, 0x0, 0x2, 0xff, 0xf4, + 0x0, 0x4, 0xff, 0xf1, 0x0, 0x9, 0xff, 0xe0, + 0x0, 0x1e, 0xff, 0x90, 0x0, 0xcf, 0xff, 0x20, + 0x3d, 0xff, 0xf8, 0x0, 0x3f, 0xff, 0xa0, 0x0, + 0x9, 0xf7, 0x0, 0x0, 0x0, 0x10, 0x0, 0x0, + + /* U+003C "<" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xae, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xdf, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x29, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4b, 0xff, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x7d, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x18, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xb4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3a, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x82, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6d, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0x8e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf9, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x71, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xfb, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xfa, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xc5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xe8, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x29, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x71, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x93, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xc5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x8f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe8, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6d, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4b, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x71, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x28, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0x8e, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6d, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4a, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x17, + + /* U+003D "=" */ + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x26, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, + 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x65, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x26, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, + 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x65, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + + /* U+003E ">" */ + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5e, 0x71, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xa3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xc6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xe8, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x92, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x17, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xb5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe7, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x8e, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5c, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x29, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x81, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x7d, 0xff, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5e, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x28, 0xef, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4b, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x7d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xa3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x28, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x81, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4b, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x7e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe8, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xfe, 0x81, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xfc, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xfa, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xe7, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x35, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+003F "?" */ + 0x0, 0x0, 0x0, 0x0, 0x1, 0x59, 0xcd, 0xff, + 0xed, 0xb8, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3a, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf9, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc2, 0x0, 0x0, 0x0, 0x2, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xdc, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x1, 0xef, + 0xff, 0xff, 0xff, 0x83, 0x0, 0x0, 0x4, 0xaf, + 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xfc, 0x10, 0x0, 0x0, 0x0, 0x0, 0x3e, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x3f, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1d, + 0xff, 0xff, 0xff, 0x40, 0xa, 0xff, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xfb, 0x0, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xf1, 0x5f, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x49, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xf6, 0xcf, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x79, 0xce, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x24, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xcf, + 0xff, 0xff, 0xfc, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, + 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xff, + 0xfc, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x35, 0x55, 0x55, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0x99, 0x99, 0x95, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0040 "@" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x26, 0x8a, 0xcd, 0xef, + 0xff, 0xee, 0xca, 0x85, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x16, 0xbe, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x94, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4a, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe8, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4c, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1a, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0xcb, 0xbb, 0xce, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xef, 0xff, 0xff, 0xff, 0xff, 0xb7, + 0x41, 0x0, 0x0, 0x0, 0x0, 0x2, 0x59, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0xfc, 0x61, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x9f, + 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xfb, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x8f, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xfe, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xbf, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x59, 0xbc, 0xca, 0x72, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xb2, 0x0, 0x0, 0x7e, 0xee, + 0xee, 0x30, 0x0, 0x0, 0x9f, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x60, 0x0, 0xbf, 0xff, 0xff, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf7, 0x0, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x52, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x1d, + 0xff, 0xff, 0xff, 0xe7, 0x30, 0x2, 0x6d, 0xff, + 0xff, 0xe8, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xf5, 0x0, 0x0, 0xa, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xf9, 0x0, 0x0, 0x1f, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xfc, 0x0, 0x0, 0x6f, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0x0, 0x0, 0xbf, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0x10, 0x0, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x20, + 0x4, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x20, 0x7, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0x20, 0xb, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0x20, 0xd, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0x10, 0xf, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xfe, 0x0, 0x1f, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xfc, 0x0, 0x2f, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf8, + 0x0, 0x3f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf5, 0x0, + 0x3f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xf0, 0x0, 0x3f, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xa0, 0x0, 0x3f, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x30, 0x0, 0x2f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xfc, 0x0, 0x0, 0x1f, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0xf, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x1, 0xdf, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0xa, 0xff, 0xff, 0x50, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x2d, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xdf, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x4, + 0xef, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x4e, 0xff, + 0xff, 0xff, 0xff, 0xf1, 0x0, 0x2, 0xaf, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xd4, 0x0, 0x0, 0x3a, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x66, 0xbf, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xff, 0xfc, 0xcf, 0xff, 0xff, 0xfb, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb0, 0x1f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x2, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf8, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x30, 0x0, 0x1, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xd5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x17, 0xce, 0xff, 0xd9, 0x30, + 0x0, 0x0, 0x0, 0x6, 0xbe, 0xff, 0xeb, 0x83, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xbb, 0xbb, 0xb6, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xcf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x1, 0xdf, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1c, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xfa, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xdf, + 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0xe4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xff, 0xa3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4d, 0xff, 0xff, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xff, 0xb4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4b, 0xff, 0xff, 0xff, 0xfc, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, + 0xff, 0xff, 0xff, 0xe9, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x7d, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc8, 0x53, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x14, 0x69, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xe5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xed, 0xcc, + 0xdd, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe9, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x59, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x94, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x36, + 0x9a, 0xcd, 0xef, 0xff, 0xff, 0xed, 0xb9, 0x74, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0041 "A" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xbf, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0x3f, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xfb, 0xe, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xf7, 0x9, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf3, 0x3, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xe0, 0x0, 0xef, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x90, + 0x0, 0x8f, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0x40, 0x0, + 0x2f, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xfe, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xc1, 0x11, 0x11, 0x11, + 0x11, 0x11, 0x11, 0x11, 0x9f, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xfe, 0x0, 0x4, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0x50, 0xa, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0xc0, 0x7, 0x88, 0x88, 0x85, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x78, 0x88, 0x88, 0x70, + + /* U+0042 "B" */ + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xed, 0xb8, 0x51, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd3, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xa9, 0x99, 0x99, 0x99, 0x99, 0x99, 0xac, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0x9f, 0xff, 0xff, 0xff, 0xd0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2d, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xfb, 0x0, 0x2, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf0, + 0x0, 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0x10, 0x2, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf3, 0x0, 0x2f, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0x30, + 0x2, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf1, 0x0, 0x2f, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xfe, 0x0, 0x2, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x90, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, + 0xf3, 0x0, 0x2, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1c, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0x9f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xa9, 0x99, 0x99, 0x99, 0x99, + 0x99, 0xab, 0xdf, 0xff, 0xff, 0xff, 0xfd, 0x10, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x20, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x11, 0x35, 0x8c, 0xff, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x9f, 0xff, + 0xff, 0xff, 0x80, 0x2, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0x20, 0x2f, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfa, + 0x2, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xf0, 0x2f, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0x32, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf6, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x72, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf8, 0x2f, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x62, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xf5, 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0x22, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xe0, 0x2f, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xf9, 0x2, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xbf, + 0xff, 0xff, 0xff, 0x20, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x49, 0xff, 0xff, 0xff, 0xff, 0x90, 0x2, 0xff, + 0xff, 0xff, 0xa9, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x9a, 0xbd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, + 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe2, 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x91, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe8, 0x20, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xdb, 0x96, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0043 "C" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x47, 0xac, 0xef, 0xff, 0xec, 0xa7, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4a, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe9, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xa1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2b, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x97, 0x65, 0x67, + 0x9d, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0xfc, 0x61, 0x0, 0x0, 0x0, 0x0, 0x2, 0x9f, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xff, 0xe5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2c, 0xff, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0xef, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xe0, 0x0, + 0xd, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0x20, 0x3, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xeb, + 0x73, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x10, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x14, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xc8, 0x40, 0x0, 0x5f, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xf0, 0x0, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xfb, + 0x0, 0xa, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0x60, 0x0, 0x4f, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xff, 0xb1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2d, 0xff, 0xff, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, + 0xe4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xfc, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xdf, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x86, 0x66, + 0x78, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x19, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x8d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe7, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x69, 0xbd, 0xef, 0xff, 0xdc, 0xa6, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0044 "D" */ + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0xdc, 0xa8, 0x52, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe8, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xc9, + 0x99, 0x99, 0x99, 0x99, 0x99, 0xab, 0xce, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x15, 0x9f, 0xff, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x9f, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0x20, 0x0, + 0xdf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0xdf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf2, 0x0, + 0xdf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xf8, 0x0, 0xdf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfd, 0x0, + 0xdf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0x20, 0xdf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x60, + 0xdf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0x90, 0xdf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xd0, + 0xdf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xf0, 0xdf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf0, + 0xdf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xf2, 0xdf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xdf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xf3, 0xdf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf3, + 0xdf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xf2, 0xdf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf2, + 0xdf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xf1, 0xdf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf0, + 0xdf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xd0, 0xdf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xb0, + 0xdf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x80, 0xdf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x50, + 0xdf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0x0, 0xdf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xfb, 0x0, + 0xdf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xf6, 0x0, 0xdf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xe0, 0x0, + 0xdf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0x80, 0x0, 0xdf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfe, 0x10, 0x0, + 0xdf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xaf, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x25, 0xbf, 0xff, 0xff, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xc9, + 0x99, 0x99, 0x99, 0x99, 0x99, 0xab, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x30, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xa4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0xdb, 0x96, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0045 "E" */ + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x60, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x60, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x60, 0xcf, 0xff, 0xff, 0xc9, 0x99, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x99, 0x99, 0x99, 0x30, 0xcf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x90, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x90, 0x0, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x90, 0x0, 0xcf, 0xff, 0xff, 0xc8, 0x88, 0x88, + 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, + 0x88, 0x88, 0x50, 0x0, 0xcf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xc9, 0x99, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x99, 0x99, 0x99, 0x94, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf7, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, + + /* U+0046 "F" */ + 0x69, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf2, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x2b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf2, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x2b, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf2, 0xbf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xc9, 0x99, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x60, 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0xb, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0x88, 0x88, 0x84, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0047 "G" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x14, 0x8a, 0xce, 0xef, 0xfe, 0xdc, 0xa7, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x16, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1b, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xc9, 0x76, 0x55, 0x67, 0xad, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1d, 0xff, 0xff, 0xff, 0xff, 0xa5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x8e, 0xff, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xff, 0xfb, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xe0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0x30, 0x0, 0xef, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xd9, + 0x40, 0x0, 0x3f, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x36, 0x10, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x18, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf1, 0x8f, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x17, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0x5f, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x13, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x9f, + 0xff, 0xff, 0xf1, 0xf, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x10, 0xdf, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf1, + 0x9, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x10, 0x4f, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf1, 0x0, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x10, 0x9, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf1, 0x0, 0x2f, 0xff, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x10, 0x0, 0x9f, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf1, 0x0, + 0x1, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0x10, 0x0, 0x5, + 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5d, 0xff, 0xff, + 0xff, 0xff, 0x10, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0xff, 0x92, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x1c, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x62, 0x0, 0x0, 0x0, 0x0, 0x15, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc2, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xdb, 0xaa, 0xbc, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0x9e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x83, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0x69, 0xbd, 0xef, 0xff, 0xed, 0xb9, 0x52, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0048 "H" */ + 0x24, 0x44, 0x44, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0x44, 0x44, 0x41, 0xbf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, + 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, + 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf5, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, 0xc9, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x99, 0x99, 0x9f, 0xff, 0xff, 0xf5, 0xbf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, + 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, + 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, + + /* U+0049 "I" */ + 0x34, 0x44, 0x44, 0x1f, 0xff, 0xff, 0xf5, 0xff, + 0xff, 0xff, 0x5f, 0xff, 0xff, 0xf5, 0xff, 0xff, + 0xff, 0x5f, 0xff, 0xff, 0xf5, 0xff, 0xff, 0xff, + 0x5f, 0xff, 0xff, 0xf5, 0xff, 0xff, 0xff, 0x5f, + 0xff, 0xff, 0xf5, 0xff, 0xff, 0xff, 0x5f, 0xff, + 0xff, 0xf5, 0xff, 0xff, 0xff, 0x5f, 0xff, 0xff, + 0xf5, 0xff, 0xff, 0xff, 0x5f, 0xff, 0xff, 0xf5, + 0xff, 0xff, 0xff, 0x5f, 0xff, 0xff, 0xf5, 0xff, + 0xff, 0xff, 0x5f, 0xff, 0xff, 0xf5, 0xff, 0xff, + 0xff, 0x5f, 0xff, 0xff, 0xf5, 0xff, 0xff, 0xff, + 0x5f, 0xff, 0xff, 0xf5, 0xff, 0xff, 0xff, 0x5f, + 0xff, 0xff, 0xf5, 0xff, 0xff, 0xff, 0x5f, 0xff, + 0xff, 0xf5, 0xff, 0xff, 0xff, 0x5f, 0xff, 0xff, + 0xf5, 0xff, 0xff, 0xff, 0x5f, 0xff, 0xff, 0xf5, + 0xff, 0xff, 0xff, 0x5f, 0xff, 0xff, 0xf5, 0xff, + 0xff, 0xff, 0x5f, 0xff, 0xff, 0xf5, 0xff, 0xff, + 0xff, 0x5f, 0xff, 0xff, 0xf5, 0xff, 0xff, 0xff, + 0x5f, 0xff, 0xff, 0xf5, 0xff, 0xff, 0xff, 0x5f, + 0xff, 0xff, 0xf5, 0xff, 0xff, 0xff, 0x5f, 0xff, + 0xff, 0xf5, 0xff, 0xff, 0xff, 0x5f, 0xff, 0xff, + 0xf5, 0xff, 0xff, 0xff, 0x5f, 0xff, 0xff, 0xf5, + + /* U+004A "J" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xd0, 0x46, 0x8b, + 0xd8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xfd, 0x1f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xc0, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xfb, 0xf, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0x90, 0xdf, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xf7, 0xa, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x40, 0x7f, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xf0, 0x2, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xfb, 0x0, 0xc, 0xff, 0xff, 0xff, 0xc3, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x4f, 0xff, 0xff, 0xff, 0xfd, 0xa9, 0xac, 0xff, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xc2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x7b, + 0xde, 0xfe, 0xdb, 0x83, 0x0, 0x0, 0x0, 0x0, + + /* U+004B "K" */ + 0x4, 0x44, 0x44, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x24, + 0x44, 0x44, 0x44, 0x30, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0x40, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xfe, 0x30, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, + 0xe3, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xfd, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0xc1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0xfc, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x3f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf5, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7d, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf6, 0x2, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0x20, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0xc0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xf8, + + /* U+004C "L" */ + 0x8, 0x88, 0x88, 0x81, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xfa, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x99, 0x99, 0x40, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf7, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x70, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf7, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x70, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, + + /* U+004D "M" */ + 0x4, 0x44, 0x44, 0x44, 0x44, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x44, 0x44, 0x44, 0x44, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xf0, 0xf, + 0xff, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xff, 0xff, 0x0, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xff, 0xf0, 0xf, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0x0, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xff, 0xff, 0xf0, 0xf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x0, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xf0, 0xf, 0xff, 0xff, 0xfc, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x0, 0xff, 0xff, 0xff, 0x6f, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xaf, + 0xff, 0xff, 0xf0, 0xf, 0xff, 0xff, 0xf1, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf4, 0xff, + 0xff, 0xff, 0x0, 0xff, 0xff, 0xff, 0xc, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfe, 0xf, 0xff, + 0xff, 0xf0, 0xf, 0xff, 0xff, 0xf0, 0x6f, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0x90, 0xff, 0xff, + 0xff, 0x0, 0xff, 0xff, 0xff, 0x1, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xf4, 0xf, 0xff, 0xff, + 0xf0, 0xf, 0xff, 0xff, 0xf0, 0xb, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xfe, 0x0, 0xff, 0xff, 0xff, + 0x0, 0xff, 0xff, 0xff, 0x0, 0x6f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0x90, 0xf, 0xff, 0xff, 0xf0, + 0xf, 0xff, 0xff, 0xf0, 0x1, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xf3, 0x0, 0xff, 0xff, 0xff, 0x0, + 0xff, 0xff, 0xff, 0x0, 0xb, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xfd, 0x0, 0xf, 0xff, 0xff, 0xf0, 0xf, + 0xff, 0xff, 0xf0, 0x0, 0x5f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0x80, 0x0, 0xff, 0xff, 0xff, 0x0, 0xff, + 0xff, 0xff, 0x0, 0x0, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xf2, 0x0, 0xf, 0xff, 0xff, 0xf0, 0xf, 0xff, + 0xff, 0xf0, 0x0, 0xb, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfd, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x0, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x70, + 0x0, 0xf, 0xff, 0xff, 0xf0, 0xf, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf2, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x0, 0xff, 0xff, 0xff, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfc, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf0, 0xf, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0x70, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x0, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xf1, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf0, 0xf, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x0, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0x60, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf0, 0xf, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xf1, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x0, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf0, 0xf, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x0, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xfa, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf0, + 0xf, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x4f, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x0, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0x50, 0x0, 0xa, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf0, 0xf, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xfa, 0x0, 0x0, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x0, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xf0, 0x0, 0x5f, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf0, 0xf, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0x40, 0xa, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x0, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xf9, 0x0, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf0, 0xf, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xe0, 0x5f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x0, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0x4a, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf0, 0xf, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf9, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x0, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf0, 0xf, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x0, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf0, 0xf, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x0, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf0, 0xf, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x0, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf0, + + /* U+004E "N" */ + 0x34, 0x44, 0x44, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x44, 0x44, 0x41, 0xcf, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf7, 0xcf, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf7, 0xcf, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf7, 0xcf, + 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf7, 0xcf, 0xff, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf7, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf7, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf7, 0xcf, 0xff, 0xff, 0x9f, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, 0x3b, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf7, 0xcf, + 0xff, 0xff, 0x31, 0xef, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf7, 0xcf, 0xff, 0xff, 0x30, 0x5f, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, + 0x30, 0xb, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf7, + 0xcf, 0xff, 0xff, 0x30, 0x1, 0xef, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, 0x30, 0x0, + 0x5f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf7, 0xcf, 0xff, + 0xff, 0x30, 0x0, 0xa, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf7, 0xcf, 0xff, 0xff, 0x30, 0x0, 0x1, 0xef, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf7, 0xcf, + 0xff, 0xff, 0x30, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf7, 0xcf, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf7, + 0xcf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf7, 0xcf, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf7, 0xcf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf7, 0xcf, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf7, 0xcf, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x8, 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xff, 0xff, 0xf3, 0x0, 0x8, 0xff, 0xff, 0xf7, + 0xcf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xfd, 0x0, 0x8, + 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0x80, 0x8, 0xff, 0xff, 0xf7, 0xcf, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xff, 0xf3, 0x8, 0xff, 0xff, + 0xf7, 0xcf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xfd, + 0x8, 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0x88, 0xff, 0xff, 0xf7, 0xcf, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xfc, 0xff, + 0xff, 0xf7, 0xcf, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, + 0xcf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xcf, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, + 0xf7, 0xcf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xff, 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xf7, 0xcf, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xf7, 0xcf, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf7, + + /* U+004F "O" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x37, 0xac, 0xef, 0xff, 0xed, 0xb8, 0x51, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x9e, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xea, 0x86, 0x66, 0x79, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xff, 0xff, 0x82, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x6c, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5e, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xd3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xbf, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xfc, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xf3, 0x0, 0x4, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xfa, + 0x0, 0x9, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0x0, + 0xd, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0x40, 0x1f, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x80, 0x5f, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xb0, 0x7f, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xe0, 0x9f, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xf0, 0xbf, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xf2, 0xdf, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xf3, 0xdf, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf3, + 0xef, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf4, 0xef, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf3, 0xdf, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xf3, 0xcf, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xf2, 0xaf, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xf0, 0x8f, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xe0, 0x5f, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xb0, 0x1f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x80, + 0xd, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x40, 0x8, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0x0, 0x3, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xfc, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, 0xd2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4e, 0xff, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xfe, 0x71, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6c, 0xff, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, 0x76, + 0x56, 0x79, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0x8e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xb6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x36, 0xac, 0xde, 0xff, 0xed, 0xb8, 0x51, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0050 "P" */ + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0xcb, 0x96, 0x30, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x30, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd1, + 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0xe, 0xff, 0xff, 0xfb, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0xac, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, 0xef, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x17, 0xff, 0xff, 0xff, 0xff, + 0x50, 0xe, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, + 0xff, 0xff, 0xfd, 0x0, 0xef, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xff, 0xf4, 0xe, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0x90, 0xef, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xfd, 0xe, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf0, 0xef, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, + 0x1e, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xf2, 0xef, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0x1e, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf0, + 0xef, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xfe, 0xe, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0xa0, 0xef, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf6, 0xe, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xff, 0x10, 0xef, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xff, 0x80, 0xe, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x27, 0xdf, 0xff, 0xff, 0xff, 0xf1, 0x0, 0xef, + 0xff, 0xff, 0xb9, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x99, 0xac, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd4, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x50, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xec, 0xa8, + 0x41, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0051 "Q" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x37, 0xac, 0xef, 0xff, 0xed, 0xb8, 0x41, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4a, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1a, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xa8, + 0x66, 0x67, 0x9c, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xfe, 0x82, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5b, 0xff, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xdf, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0xff, 0xd2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xc1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x4, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xe0, 0x0, + 0xe, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0x30, 0x2, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x5f, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xb0, 0x8, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xfd, 0x0, 0xaf, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xf0, 0xc, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0x20, 0xdf, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xf2, 0xd, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0x30, 0xef, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xf4, 0xd, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0x30, 0xdf, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xf3, 0xc, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0x20, 0xaf, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xf0, 0x8, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfe, + 0x0, 0x5f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xb0, + 0x1, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf8, 0x0, + 0xd, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x8f, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0x72, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xfc, 0x50, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xd5, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0xfb, 0x10, 0x9f, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xff, 0xfe, 0xaf, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, + 0xff, 0xff, 0xd2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x28, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0xfe, 0x72, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0xa7, 0x65, 0x67, 0x9c, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1a, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd6, 0x5e, 0xff, 0xff, 0xff, 0xfa, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4a, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x50, 0x0, 0x1c, 0xff, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x48, 0xad, 0xef, 0xff, 0xed, 0xa7, 0x40, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xaf, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2a, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x86, 0x0, + + /* U+0052 "R" */ + 0x23, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x32, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xec, 0x95, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x20, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x36, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0x10, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xaf, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xef, 0xff, 0xff, 0xf2, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4e, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5b, 0xff, 0xff, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xb6, 0x66, 0x66, 0x66, + 0x66, 0x66, 0x66, 0x67, 0x8a, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x1, 0x37, + 0xcf, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xcf, 0xff, + 0xff, 0xfd, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xe3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xff, 0x60, 0x0, 0xbf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xff, 0xf1, 0x0, 0xbf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xfa, + 0x0, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0x50, 0xbf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xff, 0xe0, 0xbf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xf9, + + /* U+0053 "S" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x14, 0x7b, + 0xde, 0xff, 0xed, 0xcb, 0x74, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xb5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2c, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xa1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xec, 0x99, 0x88, 0x9b, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xff, 0xe7, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x17, 0xdf, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xff, 0x90, 0x0, 0x2, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xf0, 0x0, 0x3, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x10, 0x0, 0x2f, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0x76, 0x54, 0x30, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xff, 0x91, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xff, 0xfa, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x62, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0xb7, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x62, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x82, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6d, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0x9e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x8c, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x59, 0xdf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x15, 0x9d, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x7d, + 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xdf, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf2, + 0x1, 0x24, 0x56, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0x50, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf7, 0xe, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x80, 0xcf, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xf8, 0x9, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0x70, 0x5f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xf4, 0x0, 0xff, 0xff, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0x10, 0x9, 0xff, 0xff, 0xff, 0xc1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xc0, 0x0, 0x1f, 0xff, 0xff, + 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xbf, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0xf9, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xdf, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xb5, 0x10, 0x0, 0x0, 0x0, 0x2, + 0x7c, 0xff, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x1, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xec, + 0xaa, 0xab, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x1, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3b, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0x9e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x71, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x69, + 0xbd, 0xef, 0xff, 0xed, 0xc9, 0x62, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0054 "T" */ + 0x59, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x99, 0x99, 0x97, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x9f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x88, 0x88, 0x88, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0055 "U" */ + 0xcf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xf6, 0xcf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xf6, 0xcf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xf6, 0xcf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xf6, 0xcf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf6, 0xcf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xf6, 0xcf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xf6, 0xcf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf6, + 0xcf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xf6, 0xcf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xf6, 0xcf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xf6, 0xcf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xf6, 0xcf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf6, 0xcf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xf6, 0xcf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xf6, 0xcf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf6, + 0xcf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xf6, 0xcf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xf6, 0xcf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xf6, 0xcf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xf6, 0xcf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf6, 0xcf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xf6, 0xcf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xf6, 0xcf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf6, + 0xcf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xf6, 0xcf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xf6, 0xcf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xf6, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xf6, 0xbf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xf5, 0xaf, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf4, 0x8f, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf3, + 0x7f, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xf1, 0x4f, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf0, 0x2f, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xd0, 0xe, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xa0, 0xb, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x60, 0x6, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0x20, 0x1, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xfc, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xfc, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0xe4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xc6, 0x10, 0x0, 0x0, 0x0, 0x3, 0x8d, + 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xba, 0xaa, + 0xbd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x1, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x17, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe8, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x59, 0xbd, 0xef, 0xff, 0xed, + 0xc9, 0x63, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0056 "V" */ + 0x48, 0x88, 0x88, 0x81, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0x88, 0x88, 0x83, 0x4f, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xf2, 0xe, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xc0, 0x8, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0x50, + 0x2, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xfe, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0x60, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0x70, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xf8, 0x0, 0x0, 0xcf, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xfe, 0x0, 0x2, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0x30, 0x7, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x90, 0xd, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xe0, 0x2f, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xf3, 0x7f, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xf7, 0xcf, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xfd, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0057 "W" */ + 0x28, 0x88, 0x88, 0x81, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0x88, 0x88, + 0x88, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0x88, 0x88, 0x82, 0x1f, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf2, 0xc, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xe0, 0x8, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0x90, 0x4, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0x50, 0x0, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0x10, 0x0, 0xbf, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xee, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xba, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x76, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x32, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0x0, 0xdf, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xfb, 0x0, 0x9f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xf6, 0x0, 0x5f, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xf2, 0x0, 0x1f, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xd0, 0x0, 0xc, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x90, + 0x0, 0x8, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x40, 0x0, + 0x3, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xf8, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0xaf, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xfc, 0x0, 0x0, 0xb, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0xef, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0x0, 0x0, 0xf, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf3, + 0x0, 0x2, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x30, 0x0, 0x4f, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf7, 0x0, + 0x6, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x70, + 0x0, 0x9f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfb, 0x0, 0xa, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xb0, 0x0, + 0xdf, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xfe, 0x0, 0xe, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xe0, 0x1, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0x20, 0x1f, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xf2, 0x4, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0x50, 0x5f, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xf5, 0x8, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0x80, 0x9f, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xf8, 0xc, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xb0, 0xcf, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xfb, 0xf, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xe0, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xfe, 0x4f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf4, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xaf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfa, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0058 "X" */ + 0x0, 0x14, 0x44, 0x44, 0x43, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0x44, 0x44, 0x44, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xff, 0xff, 0x40, 0x0, 0x9f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xe0, 0x5, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xf9, 0x1e, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0xbf, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xf9, 0xbf, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, + 0xe1, 0x2f, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0x50, 0x6, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xe1, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xfc, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0x80, 0x5f, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xf4, + + /* U+0059 "Y" */ + 0x58, 0x88, 0x88, 0x87, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x78, 0x88, 0x88, 0x82, 0x2f, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xc0, 0x7, 0xff, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xff, 0x20, 0x0, 0xcf, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xfe, 0x10, 0x1, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x90, 0xa, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xf2, 0x4f, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xfb, 0xdf, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+005A "Z" */ + 0x0, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x1f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x1f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x9, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x9f, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xdf, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, + 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xfd, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xfd, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x95, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf8, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf8, + + /* U+005B "[" */ + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf2, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf2, 0x9f, 0xff, 0xff, 0xdd, + 0xdd, 0xdd, 0xd2, 0x9f, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xdc, 0xcc, 0xcc, 0xc2, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf2, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf2, + + /* U+005C "\\" */ + 0xdf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0x30, + + /* U+005D "]" */ + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xad, 0xdd, 0xdd, 0xdf, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, 0xcc, 0xcc, + 0xcc, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + + /* U+005E "^" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xf4, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xfb, 0xc, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0x40, 0x6f, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xe0, + 0x0, 0xef, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xf7, 0x0, 0x9, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0x10, 0x0, 0x2f, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0xbf, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0x50, 0x0, 0x0, 0xd, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfd, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xb0, 0x0, 0x2f, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0x20, 0x9, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xf9, 0x1, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xf0, + + /* U+005F "_" */ + 0x13, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x6, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0x6f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x16, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0x6f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x10, + + /* U+0060 "`" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x1d, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xfb, + + /* U+0061 "a" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x14, 0x79, 0xab, + 0xcc, 0xba, 0x86, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe8, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4d, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0xb6, 0x31, 0x0, 0x12, 0x59, 0xff, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xfd, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x1, 0xcf, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x7, 0xff, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf0, 0x0, 0x4, 0xef, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0x10, 0x0, 0x0, 0x2, + 0x46, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4d, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x25, 0x8b, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x14, 0x69, 0xbd, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x6a, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x3a, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0xa5, 0xbf, 0xff, 0xff, + 0x30, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xc9, 0x62, 0x0, 0xa, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xfe, + 0xa7, 0x41, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0x30, 0x0, 0x5f, 0xff, 0xff, 0xff, 0x93, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xf3, 0x0, 0xd, 0xff, 0xff, 0xfe, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0x30, 0x2, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf3, 0x0, 0x5f, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0x30, 0x6, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xf3, 0x0, 0x7f, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xff, 0x30, 0x5, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x3f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0xef, + 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x19, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x2, + 0x8e, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0xe, 0xff, 0xff, 0xff, 0xff, 0xc9, 0x89, 0xbd, + 0xff, 0xff, 0xff, 0xe5, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x2e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb1, 0xe, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x3d, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x60, 0x0, 0xbf, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x8, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd6, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x59, 0xce, 0xff, + 0xfd, 0xa7, 0x20, 0x0, 0x0, 0x0, 0x3, 0x33, + 0x33, 0x30, + + /* U+0062 "b" */ + 0x8f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0x40, 0x0, 0x1, + 0x69, 0xbc, 0xba, 0x74, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, 0x2a, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x81, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x40, 0x6f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf4, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd7, 0x21, 0x2, + 0x5b, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x3, 0xef, 0xff, 0xff, 0xf2, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xff, 0xc0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0x30, 0x8, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xfa, 0x0, 0x8f, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf1, 0x8, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0x50, 0x8f, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xf8, 0x8, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xc0, 0x8f, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xfe, 0x8, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf0, 0x8f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0x8, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xf1, 0x8f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0x18, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf0, + 0x8f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0x8, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xd0, 0x8f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xfb, 0x8, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0x80, 0x8f, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xf4, 0x8, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0x0, 0x8f, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0x90, 0x8, 0xff, 0xff, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xf2, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, + 0xff, 0xfa, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, + 0xc1, 0x0, 0x0, 0x0, 0x0, 0x4e, 0xff, 0xff, + 0xff, 0x10, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xf7, 0x10, 0x0, 0x3, 0x9f, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x8, 0xff, 0xff, 0xdb, 0xff, 0xff, + 0xff, 0xec, 0xdf, 0xff, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x8f, 0xff, 0xfd, 0x1d, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xd0, 0x1c, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0x40, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xfd, 0x0, 0x7, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xf8, 0x10, 0x0, 0x0, 0x0, + 0x2, 0x44, 0x44, 0x30, 0x0, 0x0, 0x6a, 0xdf, + 0xff, 0xda, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0063 "c" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x69, 0xab, + 0xba, 0x96, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7d, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd7, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xff, 0xfc, 0x73, 0x10, 0x14, 0x9f, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0xe5, 0x0, 0x0, 0x0, 0x0, 0x1c, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xf2, 0x0, 0xf, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0x70, 0x5, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xfb, 0x0, 0xaf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xb9, + 0x64, 0x10, 0xd, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x13, 0x10, 0x0, 0x0, 0xef, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xfd, 0xb3, 0xa, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0x20, 0x6f, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xe0, 0x1, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xfa, 0x0, 0xa, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0x30, 0x0, 0x2f, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xfd, 0x61, + 0x0, 0x0, 0x16, 0xdf, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xff, 0xfe, + 0xdc, 0xef, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4b, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x92, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x6a, 0xce, 0xff, 0xed, + 0xa5, 0x10, 0x0, 0x0, 0x0, 0x0, + + /* U+0064 "d" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x26, + 0x9b, 0xcc, 0xb8, 0x40, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x5, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xe7, 0x0, 0xb, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x2c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x20, 0xbf, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x3e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x2b, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0xcf, 0xff, 0xff, 0x10, + 0x0, 0xe, 0xff, 0xff, 0xff, 0xe8, 0x31, 0x1, + 0x49, 0xef, 0xff, 0xff, 0xff, 0xff, 0xf1, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x1, 0xbf, 0xff, 0xff, 0xff, 0xff, 0x10, 0x4, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xff, 0xf1, 0x0, 0xbf, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xff, 0x10, 0x2f, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xf1, 0x8, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0x10, 0xcf, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xf1, 0xf, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x13, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xf1, 0x6f, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0x17, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xf1, 0x8f, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0x19, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xf1, 0x9f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0x19, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf1, + 0x8f, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x16, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf1, 0x3f, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x10, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf1, 0xc, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x10, 0x7f, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xf1, 0x2, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xff, 0x10, 0xa, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xf1, 0x0, 0x2f, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x8f, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xfd, 0x61, 0x0, 0x0, 0x5c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x10, 0x0, 0x1, 0xef, 0xff, 0xff, + 0xff, 0xfe, 0xcd, 0xff, 0xff, 0xff, 0xf9, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x5f, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x1, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf7, 0x5, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x5d, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc3, 0x0, 0x5f, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x4, 0x8c, 0xef, + 0xfe, 0xc9, 0x30, 0x0, 0x1, 0x44, 0x44, 0x40, + + /* U+0065 "e" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x58, 0xab, + 0xcb, 0xa8, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5b, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xa1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, + 0xfd, 0x83, 0x10, 0x13, 0x7d, 0xff, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0x10, 0x0, 0xc, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf8, 0x0, 0x3, 0xff, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xe0, 0x0, 0x8f, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0x30, 0xc, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xf7, 0x0, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xa0, 0x2f, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfd, 0x4, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf1, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x16, 0xff, 0xff, 0xfe, 0xcc, 0xcc, 0xcc, + 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, + 0xcc, 0xc0, 0x5f, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x97, 0x53, 0x10, 0x0, 0x6f, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x1, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xf6, 0x0, 0xa, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0x10, 0x0, 0x2f, + 0xff, 0xff, 0xfd, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xfe, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xff, 0xb5, 0x10, 0x0, + 0x1, 0x6d, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x1, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xed, + 0xde, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xc2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x29, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x48, + 0xbd, 0xff, 0xfe, 0xda, 0x72, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0066 "f" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x13, 0x44, + 0x32, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x18, + 0xdf, 0xff, 0xff, 0xff, 0xe5, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xff, 0xf9, 0x31, 0x0, + 0x23, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x38, 0x88, 0x8a, 0xff, 0xff, + 0xfb, 0x88, 0x88, 0x88, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x10, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf1, 0x0, 0x7f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0x88, 0x88, 0x83, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+0067 "g" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x26, 0x9b, 0xcc, + 0xb9, 0x51, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xf9, 0x10, 0x0, 0xef, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x2c, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x60, 0xe, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x80, 0xef, 0xff, 0xf6, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x8e, 0xff, 0xff, 0x60, 0x0, 0x1f, + 0xff, 0xff, 0xff, 0xe8, 0x31, 0x1, 0x38, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0xb, 0xff, + 0xff, 0xff, 0xa1, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0x60, 0x5, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0xf6, 0x0, 0xdf, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0x60, 0x3f, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0xf6, 0xa, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0x60, 0xef, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf6, 0x2f, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0x65, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xf6, 0x8f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0x69, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, + 0xaf, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x6b, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf6, 0xbf, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x6a, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, 0x9f, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x67, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xf6, 0x3f, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x60, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xf6, 0xb, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0x60, 0x5f, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xf6, 0x0, 0xef, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0x60, 0x6, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0xc, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x4e, 0xff, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xd6, + 0x10, 0x0, 0x4, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, + 0xed, 0xef, 0xff, 0xff, 0xff, 0xef, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x98, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x4e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x70, 0x8f, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x18, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x30, 0x8, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x59, 0xce, 0xff, 0xec, + 0x83, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xf0, 0x8, 0xfd, 0xa8, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xfc, 0x0, 0x7f, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0x80, 0x5, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xf3, 0x0, 0x1f, 0xff, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1b, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x3, 0xff, 0xff, 0xff, 0xf8, + 0x30, 0x0, 0x0, 0x3, 0x8f, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0xdd, 0xef, 0xff, 0xff, 0xff, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc1, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x15, 0x8b, 0xde, 0xff, + 0xed, 0xb8, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0068 "h" */ + 0x24, 0x44, 0x44, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x16, 0xad, 0xff, 0xed, 0xb8, 0x40, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x40, 0x2, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd5, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf4, 0x6, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x49, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x8, 0xff, + 0xff, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf7, 0x0, 0x8f, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x73, 0x10, 0x14, 0x9f, 0xff, + 0xff, 0xff, 0xe0, 0x8, 0xff, 0xff, 0xff, 0xff, + 0xe5, 0x0, 0x0, 0x0, 0x0, 0x2d, 0xff, 0xff, + 0xff, 0x50, 0x8f, 0xff, 0xff, 0xff, 0xc1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xfa, + 0x8, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xe0, 0x8f, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x18, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xf2, 0x8f, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0x48, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf4, 0x8f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x58, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xf5, 0x8f, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0x58, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xf5, 0x8f, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0x58, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf5, + 0x8f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x58, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xf5, 0x8f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0x58, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf5, 0x8f, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0x58, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf5, 0x8f, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0x58, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf5, 0x8f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0x58, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xf5, 0x8f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x58, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xf5, 0x8f, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0x58, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xf5, 0x8f, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0x58, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf5, + + /* U+0069 "i" */ + 0x9f, 0xff, 0xff, 0x39, 0xff, 0xff, 0xf3, 0x9f, + 0xff, 0xff, 0x39, 0xff, 0xff, 0xf3, 0x9f, 0xff, + 0xff, 0x39, 0xff, 0xff, 0xf3, 0x6a, 0xaa, 0xaa, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x23, 0x33, 0x33, 0x9, 0xff, 0xff, + 0xf3, 0x9f, 0xff, 0xff, 0x39, 0xff, 0xff, 0xf3, + 0x9f, 0xff, 0xff, 0x39, 0xff, 0xff, 0xf3, 0x9f, + 0xff, 0xff, 0x39, 0xff, 0xff, 0xf3, 0x9f, 0xff, + 0xff, 0x39, 0xff, 0xff, 0xf3, 0x9f, 0xff, 0xff, + 0x39, 0xff, 0xff, 0xf3, 0x9f, 0xff, 0xff, 0x39, + 0xff, 0xff, 0xf3, 0x9f, 0xff, 0xff, 0x39, 0xff, + 0xff, 0xf3, 0x9f, 0xff, 0xff, 0x39, 0xff, 0xff, + 0xf3, 0x9f, 0xff, 0xff, 0x39, 0xff, 0xff, 0xf3, + 0x9f, 0xff, 0xff, 0x39, 0xff, 0xff, 0xf3, 0x9f, + 0xff, 0xff, 0x39, 0xff, 0xff, 0xf3, 0x9f, 0xff, + 0xff, 0x39, 0xff, 0xff, 0xf3, 0x9f, 0xff, 0xff, + 0x39, 0xff, 0xff, 0xf3, 0x9f, 0xff, 0xff, 0x39, + 0xff, 0xff, 0xf3, 0x9f, 0xff, 0xff, 0x39, 0xff, + 0xff, 0xf3, 0x9f, 0xff, 0xff, 0x39, 0xff, 0xff, + 0xf3, 0x9f, 0xff, 0xff, 0x30, + + /* U+006A "j" */ + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x6, 0xbb, 0xbb, + 0xb2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xc0, 0x6, 0x42, 0x26, 0xef, 0xff, 0xff, 0x70, + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0x20, 0x4f, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xe2, 0x0, 0xbf, 0xff, 0xff, + 0xff, 0xfd, 0x30, 0x0, 0x6a, 0xde, 0xfe, 0xda, + 0x50, 0x0, 0x0, + + /* U+006B "k" */ + 0x24, 0x44, 0x44, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x33, + 0x33, 0x33, 0x10, 0x9f, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, + 0xa0, 0x9, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0x90, 0x0, 0x9, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xf3, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0x30, 0x0, 0xa, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xf3, 0x0, 0xa, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, + 0xa, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xf3, 0xa, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0x39, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xdf, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0x41, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0x30, 0x6, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0x30, 0x0, 0xc, 0xff, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xff, 0xf1, 0x0, 0x9, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0x60, 0x9, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0xff, 0x20, 0x9f, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xfb, 0x9, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf6, + + /* U+006C "l" */ + 0x24, 0x44, 0x44, 0xa, 0xff, 0xff, 0xf2, 0xaf, + 0xff, 0xff, 0x2a, 0xff, 0xff, 0xf2, 0xaf, 0xff, + 0xff, 0x2a, 0xff, 0xff, 0xf2, 0xaf, 0xff, 0xff, + 0x2a, 0xff, 0xff, 0xf2, 0xaf, 0xff, 0xff, 0x2a, + 0xff, 0xff, 0xf2, 0xaf, 0xff, 0xff, 0x2a, 0xff, + 0xff, 0xf2, 0xaf, 0xff, 0xff, 0x2a, 0xff, 0xff, + 0xf2, 0xaf, 0xff, 0xff, 0x2a, 0xff, 0xff, 0xf2, + 0xaf, 0xff, 0xff, 0x2a, 0xff, 0xff, 0xf2, 0xaf, + 0xff, 0xff, 0x2a, 0xff, 0xff, 0xf2, 0xaf, 0xff, + 0xff, 0x2a, 0xff, 0xff, 0xf2, 0xaf, 0xff, 0xff, + 0x2a, 0xff, 0xff, 0xf2, 0xaf, 0xff, 0xff, 0x2a, + 0xff, 0xff, 0xf2, 0xaf, 0xff, 0xff, 0x2a, 0xff, + 0xff, 0xf2, 0xaf, 0xff, 0xff, 0x2a, 0xff, 0xff, + 0xf2, 0xaf, 0xff, 0xff, 0x2a, 0xff, 0xff, 0xf2, + 0xaf, 0xff, 0xff, 0x2a, 0xff, 0xff, 0xf2, 0xaf, + 0xff, 0xff, 0x2a, 0xff, 0xff, 0xf2, 0xaf, 0xff, + 0xff, 0x2a, 0xff, 0xff, 0xf2, 0xaf, 0xff, 0xff, + 0x2a, 0xff, 0xff, 0xf2, 0xaf, 0xff, 0xff, 0x2a, + 0xff, 0xff, 0xf2, 0xaf, 0xff, 0xff, 0x2a, 0xff, + 0xff, 0xf2, 0xaf, 0xff, 0xff, 0x2a, 0xff, 0xff, + 0xf2, 0xaf, 0xff, 0xff, 0x2a, 0xff, 0xff, 0xf2, + + /* U+006D "m" */ + 0x23, 0x33, 0x31, 0x0, 0x0, 0x4, 0x9c, 0xef, + 0xfe, 0xc9, 0x30, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x7b, 0xef, 0xfe, 0xc9, 0x50, 0x0, 0x0, 0xb, + 0xff, 0xff, 0x80, 0x0, 0x5d, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xc3, 0x0, 0x0, 0x0, 0x1a, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe6, 0x0, 0x0, 0xbf, + 0xff, 0xf8, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0xb, 0xff, + 0xff, 0x80, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf3, 0x0, 0x6f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0xbf, 0xff, + 0xf8, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd0, 0x5f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf2, 0xb, 0xff, 0xff, + 0xef, 0xff, 0xff, 0xa5, 0x20, 0x14, 0xbf, 0xff, + 0xff, 0xff, 0x7f, 0xff, 0xff, 0xa5, 0x21, 0x13, + 0x7e, 0xff, 0xff, 0xff, 0x90, 0xbf, 0xff, 0xff, + 0xff, 0xfb, 0x20, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x20, 0x0, 0x0, 0x0, + 0x1d, 0xff, 0xff, 0xff, 0xb, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xf3, 0xbf, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0x7b, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xf9, 0xbf, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xab, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xfa, 0xbf, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xbb, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xfb, 0xbf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xbb, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfb, + 0xbf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xbb, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfb, 0xbf, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xbb, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xfb, 0xbf, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xbb, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xfb, 0xbf, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xbb, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xfb, 0xbf, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xbb, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xfb, 0xbf, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xbb, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xfb, 0xbf, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xbb, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xfb, 0xbf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xbb, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfb, + 0xbf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xbb, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfb, 0xbf, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xb0, + + /* U+006E "n" */ + 0x13, 0x33, 0x32, 0x0, 0x0, 0x1, 0x6a, 0xdf, + 0xff, 0xeb, 0x82, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xb0, 0x0, 0x2a, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x30, 0x0, 0x0, 0x8f, 0xff, 0xfb, + 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x8, 0xff, 0xff, 0xb0, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x8f, 0xff, 0xfb, 0x6f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, + 0x8, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xc7, 0x31, + 0x2, 0x49, 0xff, 0xff, 0xff, 0xff, 0x10, 0x8f, + 0xff, 0xff, 0xff, 0xfe, 0x40, 0x0, 0x0, 0x0, + 0x1, 0xdf, 0xff, 0xff, 0xf6, 0x8, 0xff, 0xff, + 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xb0, 0x8f, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xfe, 0x8, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xf0, 0x8f, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x28, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xf3, 0x8f, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0x48, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf4, 0x8f, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x48, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, + 0x8f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x48, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf4, 0x8f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x48, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf4, 0x8f, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0x48, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x8f, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0x48, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf4, 0x8f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x48, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf4, 0x8f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x48, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x8f, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x48, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf4, 0x8f, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x48, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, + 0x8f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x48, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf4, 0x8f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x40, + + /* U+006F "o" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x59, 0xbc, + 0xcb, 0xa8, 0x51, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6c, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, + 0xfc, 0x73, 0x10, 0x13, 0x8e, 0xff, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xe5, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x4f, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xfe, 0x0, 0x9, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xf4, 0x0, 0xef, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0x90, 0x2f, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xfd, 0x5, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf0, 0x7f, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x29, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf4, + 0xaf, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0x5a, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xf6, 0xaf, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0x5a, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xf5, 0x9f, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x47, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xf2, 0x5f, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x2, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xd0, 0xe, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xf9, 0x0, 0xaf, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0x50, 0x5, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xe0, 0x0, 0xe, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2e, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xfc, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x4e, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x2, 0xef, 0xff, 0xff, 0xff, 0x93, 0x0, 0x0, + 0x5, 0xbf, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x3, 0xef, 0xff, 0xff, 0xff, 0xff, 0xdc, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2a, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe8, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x59, + 0xce, 0xff, 0xfe, 0xb8, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0070 "p" */ + 0x25, 0x55, 0x54, 0x0, 0x0, 0x5, 0x9d, 0xff, + 0xfe, 0xb8, 0x30, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xc0, 0x0, 0x6e, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd5, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xfc, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x10, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xc0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x8f, 0xff, + 0xfc, 0xaf, 0xff, 0xff, 0xfc, 0xa9, 0xbe, 0xff, + 0xff, 0xff, 0xfd, 0x10, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x71, 0x0, 0x0, 0x4, 0xdf, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xff, 0xfd, 0x20, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xf4, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xe0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xff, 0xff, 0x60, 0x8, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xfc, 0x0, 0x8f, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xf3, 0x8, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0x70, 0x8f, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xfa, 0x8, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xe0, 0x8f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0x8, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf1, + 0x8f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x28, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf2, 0x8f, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x28, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xf1, 0x8f, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xff, 0x8, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xe0, 0x8f, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xfb, 0x8, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0x80, 0x8f, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xf3, 0x8, 0xff, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xfe, 0x0, 0x8f, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0x80, 0x8, 0xff, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xf1, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf9, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xd3, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x52, + 0x1, 0x27, 0xdf, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x8, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x4b, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf4, 0x9, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x20, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x40, 0x4, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xd5, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x37, 0xab, 0xcb, 0x96, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0071 "q" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x59, 0xce, 0xff, + 0xeb, 0x72, 0x0, 0x0, 0x5, 0x55, 0x55, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x20, 0x2, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x4e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x50, 0x2f, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x62, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xfd, 0xa9, 0xbd, 0xff, + 0xff, 0xff, 0x6f, 0xff, 0xff, 0x10, 0x0, 0x1f, + 0xff, 0xff, 0xff, 0x92, 0x0, 0x0, 0x3, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xf1, 0x0, 0xb, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0xff, 0x10, 0x5, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0xf1, 0x0, 0xcf, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0x10, 0x3f, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0xf1, 0x9, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0x10, 0xcf, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xf1, 0xf, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0x13, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xf1, 0x5f, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0x16, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf1, + 0x7f, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0x18, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf1, 0x8f, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x17, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xf1, 0x6f, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0x14, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xf1, 0x1f, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x10, 0xdf, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xf1, 0x9, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x10, 0x4f, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xf1, 0x0, 0xdf, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xff, 0x10, 0x6, 0xff, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xf1, 0x0, 0xd, 0xff, 0xff, 0xfd, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xff, 0x10, 0x0, 0x3f, 0xff, 0xff, 0xfd, 0x30, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xb5, + 0x20, 0x13, 0x8e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x10, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe4, 0xb, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x18, 0xef, 0xff, 0xff, 0xff, + 0xfe, 0x80, 0x0, 0xbf, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x48, 0xab, 0xcb, 0x85, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf1, + + /* U+0072 "r" */ + 0x23, 0x33, 0x31, 0x0, 0x0, 0x7c, 0xff, 0xda, + 0x40, 0xb, 0xff, 0xff, 0x80, 0x3, 0xdf, 0xff, + 0xff, 0xff, 0xd5, 0xbf, 0xff, 0xf8, 0x3, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xab, 0xff, 0xff, 0x81, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xf4, 0xbf, 0xff, + 0xf8, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xb, + 0xff, 0xff, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x80, 0xbf, 0xff, 0xff, 0xff, 0xfd, 0x62, 0x1, + 0x49, 0xf2, 0xb, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x1, 0x0, 0xbf, 0xff, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0073 "s" */ + 0x0, 0x0, 0x0, 0x0, 0x15, 0x8a, 0xbc, 0xba, + 0x96, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xea, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2b, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xb1, 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe4, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe2, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0xb6, 0x31, 0x0, + 0x14, 0x8e, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x4, + 0xff, 0xff, 0xfe, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x1a, 0xff, 0xff, 0xff, 0x30, 0x0, 0xaf, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xf9, 0x0, 0xd, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xd0, 0x0, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfe, + 0x10, 0xf, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0x75, 0x30, 0x0, 0x0, + 0xef, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0x92, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xff, 0xfc, 0x72, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x84, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb6, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd7, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x28, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x38, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x15, 0x9e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x7c, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x8f, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xf4, 0x13, 0x68, 0xbb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x6d, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf6, 0x9f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x45, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xf2, 0xe, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xfd, 0x0, 0x7f, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0x60, 0x0, 0xdf, 0xff, 0xff, 0xfe, + 0x72, 0x0, 0x0, 0x1, 0x5c, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xdc, 0xde, 0xff, 0xff, 0xff, 0xff, 0xe2, 0x0, + 0x0, 0x3, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe3, 0x0, 0x0, 0x0, + 0x2, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x69, 0xce, 0xef, 0xfe, 0xca, 0x62, 0x0, 0x0, + 0x0, 0x0, + + /* U+0074 "t" */ + 0x0, 0x0, 0x0, 0x0, 0x2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4d, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xbf, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x78, 0x88, + 0xdf, 0xff, 0xff, 0x88, 0x88, 0x87, 0xf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xc7, 0x67, 0x90, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x1, 0x7b, 0xef, 0xfe, 0xdb, 0x60, + + /* U+0075 "u" */ + 0xaf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x1a, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xf1, 0xaf, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0x1a, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xf1, 0xaf, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0x1a, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf1, 0xaf, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x1a, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xf1, 0xaf, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x1a, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xf1, 0xaf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x1a, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xf1, 0xaf, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0x1a, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xf1, 0xaf, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0x1a, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf1, + 0xaf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x1a, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xf1, 0xaf, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0x1a, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xf1, 0xaf, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0x1a, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf1, 0xaf, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0x19, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xf1, 0x8f, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0x16, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xf1, 0x3f, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0x10, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xf1, 0xb, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0x10, 0x5f, 0xff, 0xff, + 0xff, 0xd7, 0x20, 0x1, 0x38, 0xef, 0xff, 0xfb, + 0xff, 0xff, 0xf1, 0x0, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x2f, 0xff, + 0xff, 0x10, 0x1, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x11, 0xff, 0xff, 0xf1, + 0x0, 0x1, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x10, 0x1f, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x6e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd5, + 0x0, 0x1, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x4, 0x9c, 0xef, 0xfe, 0xc9, 0x40, 0x0, 0x0, + 0x3, 0x33, 0x33, 0x0, + + /* U+0076 "v" */ + 0xe, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0x10, 0x9f, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xa0, 0x3, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xf4, 0x0, 0xd, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0x80, 0x0, 0x1, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0xef, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0x50, 0x0, 0x4f, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xfb, 0x0, 0x9, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf1, 0x0, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x60, 0x5f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xfb, 0xa, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xf1, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0x9f, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+0077 "w" */ + 0x8f, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf1, + 0x3f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xc0, + 0xe, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x70, + 0x9, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x20, + 0x4, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfd, 0x0, + 0x0, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xfa, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x90, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xf5, 0xdf, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xf1, 0x9f, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xd0, 0x6f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0x80, 0x2f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0x10, 0x0, 0x0, + 0xa, 0xff, 0xff, 0x40, 0xe, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0x50, 0x0, 0x0, + 0xf, 0xff, 0xff, 0x0, 0xa, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x3f, 0xff, 0xfc, 0x0, 0x6, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x8f, 0xff, 0xf7, 0x0, 0x2, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0xcf, 0xff, 0xf3, 0x0, 0x0, 0xdf, 0xff, 0xf8, + 0x0, 0x0, 0x9f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xf7, 0x0, 0x1, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x9f, 0xff, 0xfc, + 0x0, 0x0, 0xef, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfb, 0x0, 0x5, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0x0, 0x3, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x0, 0x9, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0x40, 0x7, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x40, 0xd, + 0xff, 0xff, 0x20, 0x0, 0x0, 0xc, 0xff, 0xff, + 0x90, 0xc, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x90, 0x1f, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xd0, 0x1f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xd0, 0x5f, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xf1, 0x6f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf1, 0x9f, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xf5, 0xaf, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf6, 0xdf, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xfa, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xfc, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0078 "x" */ + 0x1, 0x33, 0x33, 0x33, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x13, 0x33, 0x33, 0x31, + 0x0, 0x2f, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x5f, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xe1, 0x3, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xff, 0xa0, 0xdf, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xbf, 0xff, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xfd, 0xff, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xfd, 0xd, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0x30, 0x3f, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x8f, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xd0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x7f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0x70, 0x3f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xff, 0x30, + + /* U+0079 "y" */ + 0xcf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf3, + 0x5f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xd0, + 0xf, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x70, + 0x9, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0x10, + 0x3, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x90, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x90, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0xef, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x0, + 0x3, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x50, + 0x9, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xb0, + 0xe, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf0, + 0x3f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf4, + 0x7f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf9, + 0xcf, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xfe, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1a, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7e, 0xba, 0xac, 0xff, 0xff, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xff, 0xfb, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xad, 0xff, 0xd9, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+007A "z" */ + 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x6, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x4, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x9a, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0xfd, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xe2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xdf, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xfe, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xec, 0xde, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x9b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9b, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + + /* U+007B "{" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x27, 0xbd, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1a, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xdf, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xe7, 0x31, 0x10, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4e, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0x8c, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xe3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xfa, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xb1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x27, 0xdf, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xd6, + 0x31, 0x10, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x49, 0xce, 0xff, 0xf8, + + /* U+007C "|" */ + 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, + 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, + 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, + 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, + 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, + 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, + 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, + 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, + 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, + 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, + 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, + 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, + 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, + 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, + 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, + 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, + 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, + 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, + 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, + 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, + 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, + 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, + 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, + 0xff, 0xf2, + + /* U+007D "}" */ + 0x7f, 0xff, 0xec, 0x94, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x13, 0x6d, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xe4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xc8, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3e, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x9f, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1a, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xfe, 0x72, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xb1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x13, 0x7d, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0xb1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xeb, 0x83, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+007E "~" */ + 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x16, 0xbe, 0xff, 0xff, 0xc9, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x29, 0x0, 0x18, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xec, 0x2, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x40, 0x0, 0x0, + 0x0, 0x1, 0xaf, 0xfc, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x95, + 0x21, 0x25, 0xaf, 0xff, 0xfc, 0x3f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x3f, + 0xff, 0xfc, 0x62, 0x10, 0x25, 0x9e, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x3f, 0xfd, 0x40, 0x0, 0x0, 0x0, 0x0, 0x39, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x80, 0x3f, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xb3, 0x0, 0x37, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x59, 0xce, 0xff, 0xdb, + 0x72, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+00A0 " " */ + + /* U+00A3 "£" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x48, + 0x9a, 0xbb, 0x98, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xa3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xff, 0xd7, 0x31, 0x1, 0x49, + 0xff, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x1b, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x50, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0x90, 0x0, 0x1, 0xff, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xfd, 0xb8, 0x40, 0x0, 0x2, 0xff, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5c, 0xcc, 0xcc, 0xcf, 0xff, 0xff, + 0xfc, 0xcc, 0xcc, 0xcc, 0xcc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0x66, 0x9b, 0xba, + 0x98, 0x51, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x10, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xea, 0x73, 0x0, 0x0, 0x0, + 0x4, 0xaf, 0x70, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xa9, + 0x9b, 0xff, 0xff, 0xc0, 0x9f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf2, 0x3f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xd, 0xff, + 0xff, 0xea, 0x63, 0x10, 0x2, 0x47, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x6, + 0xff, 0xc5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x49, 0xef, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x81, + 0x0, 0xd5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0x6a, 0xdf, 0xfe, 0xb8, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+00A4 "¤" */ + 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x30, 0x0, + 0x0, 0x0, 0xaf, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0x50, + 0x0, 0x0, 0xaf, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x23, 0x43, 0x10, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0x50, 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x6b, + 0xff, 0xff, 0xff, 0xea, 0x40, 0x0, 0x7f, 0xff, + 0xff, 0x50, 0x3f, 0xff, 0xff, 0xff, 0x36, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd3, 0x7f, 0xff, + 0xff, 0xfe, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x20, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x20, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xe7, 0x31, 0x1, 0x5a, 0xff, 0xff, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x2, 0xdf, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xdf, 0xff, 0xff, 0x10, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfd, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0x90, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xef, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xc3, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xfc, 0x75, 0x46, 0x9e, 0xff, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x9f, 0xff, + 0xff, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xef, 0xff, 0xff, 0xff, 0x50, 0x3f, 0xff, + 0xff, 0xfc, 0x12, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x80, 0x3f, 0xff, 0xff, 0xfe, 0x0, 0x5f, + 0xff, 0xfc, 0x10, 0x0, 0x16, 0xad, 0xff, 0xed, + 0x95, 0x0, 0x0, 0x3f, 0xff, 0xfe, 0x20, 0x0, + 0x6f, 0xfc, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xfe, 0x20, 0x0, + 0x0, 0x6c, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3e, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+00A5 "¥" */ + 0xbf, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x52, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0xc0, 0x9, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf3, 0x0, + 0x1e, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xf2, 0x0, 0x9, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xa0, 0x1, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, + 0x30, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xfa, 0x1f, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xec, 0xcc, 0xcc, + 0xcc, 0xcc, 0xc7, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0xe, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x90, 0x0, 0xe, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x67, 0x77, 0x77, 0x77, 0x77, 0x77, 0x7b, + 0xff, 0xff, 0xfa, 0x77, 0x77, 0x77, 0x77, 0x77, + 0x77, 0x40, 0x0, 0xe, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x48, 0x88, 0x88, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00A6 "¦" */ + 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, + 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, + 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, + 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, + 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, + 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, + 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, + 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, + 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, + 0xff, 0xff, 0xf2, 0x67, 0x77, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x78, 0x88, 0x81, 0xff, + 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, + 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, + 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, + 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, + 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, + 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, + 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, + 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, + 0xf2, 0xff, 0xff, 0xf2, 0xff, 0xff, 0xf2, 0xff, + 0xff, 0xf2, + + /* U+00A7 "§" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x16, 0xad, 0xef, + 0xfe, 0xc9, 0x61, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x19, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xa3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xed, + 0xce, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0x92, 0x0, + 0x0, 0x29, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xa8, 0x75, 0x30, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xc2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3a, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2b, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xef, 0xff, 0xff, 0xad, 0xff, 0xff, + 0xff, 0xff, 0xe4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xe4, 0x1, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xa1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xfd, 0x10, 0x0, 0x5, 0xef, + 0xff, 0xff, 0xff, 0xfe, 0x50, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x1a, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x4e, 0xff, 0xff, 0xff, 0xff, 0xd2, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x3f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xdf, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x3f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xfe, 0x10, + 0x2f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xa0, + 0xf, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xef, 0xff, 0xff, 0xf2, + 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf7, + 0x6, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xfa, + 0x0, 0xdf, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0xd3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfc, + 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfb, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xfe, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf8, + 0x0, 0x0, 0x3, 0xef, 0xff, 0xff, 0xff, 0xfb, + 0x20, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x1c, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0xd3, 0x0, 0x1, 0xcf, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0x80, 0x4e, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1b, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5e, + 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x9f, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xef, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1b, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x35, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x2c, 0xef, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xe7, 0x20, + 0x0, 0x4, 0xaf, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xdf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x7b, 0xde, + 0xff, 0xec, 0x95, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00A8 "¨" */ + 0x9, 0x99, 0x99, 0x90, 0x0, 0x0, 0x9, 0x99, + 0x99, 0x90, 0xf, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf0, 0xf, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf0, 0xf, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf0, + 0xf, 0xff, 0xff, 0xf0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf0, 0xf, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf0, 0xf, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf0, + + /* U+00A9 "©" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x37, 0xac, 0xef, 0xff, 0xec, 0xa7, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x49, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xc4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4d, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x9f, + 0xff, 0xff, 0xff, 0xd9, 0x63, 0x11, 0x1, 0x25, + 0x8b, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xdf, + 0xff, 0xff, 0xf9, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x6d, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xef, + 0xff, 0xff, 0x91, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xdf, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1c, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1d, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x26, + 0xbd, 0xef, 0xfd, 0xb7, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x2e, 0xff, 0xfe, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x3, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xa1, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xf8, 0x0, 0x0, 0x5, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf1, 0x0, 0x0, + 0xdf, 0xff, 0x90, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xdb, 0xaa, 0xdf, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x80, 0x0, + 0x4f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf9, 0x20, 0x0, 0x0, 0x29, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x0, + 0x9, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf5, + 0x0, 0xef, 0xff, 0x30, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xa0, 0x3f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xe5, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xfe, 0x7, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x36, 0x20, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf2, 0xaf, 0xff, 0x60, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x4c, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf7, 0xdf, 0xff, 0x20, 0x0, 0x0, + 0x3, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0x8f, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf9, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x9f, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf9, 0xef, 0xff, 0x10, + 0x0, 0x0, 0x4, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0x8d, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf7, 0xaf, 0xff, + 0x60, 0x0, 0x0, 0x0, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x48, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0xc, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xd9, + 0x40, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf2, 0x4f, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfe, 0x0, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xa0, + 0xb, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf5, + 0x0, 0x5f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x4, 0xdf, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x0, 0x0, 0xef, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xd7, 0x20, 0x1, 0x5b, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x80, 0x0, 0x7, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xf1, 0x0, 0x0, 0xe, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x5e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x19, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xb4, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x38, 0x9b, 0xbb, + 0x96, 0x20, 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1c, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2d, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xef, 0xff, 0xff, 0x91, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xcf, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xdf, 0xff, 0xff, 0xf9, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4b, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xaf, 0xff, 0xff, 0xff, 0xd9, + 0x63, 0x11, 0x1, 0x24, 0x7a, 0xef, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5e, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfb, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xc4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6c, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x58, 0xbd, 0xef, 0xff, 0xec, 0xa7, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+00AA "ª" */ + 0x0, 0x0, 0x1, 0x6b, 0xdf, 0xed, 0x94, 0x0, + 0x0, 0xff, 0xff, 0xa0, 0x0, 0x6, 0xef, 0xff, + 0xff, 0xff, 0xfb, 0x10, 0x4f, 0xff, 0xf5, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x28, + 0xff, 0xff, 0x10, 0x8, 0xff, 0xff, 0xff, 0xb9, + 0xbf, 0xff, 0xfd, 0xdf, 0xff, 0xc0, 0x3, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x1a, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0xcf, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xff, 0x40, 0x2f, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf1, + 0x7, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xfd, 0x0, 0xaf, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xa0, 0xd, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xf7, 0x0, 0xef, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0x40, 0xf, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xf1, 0x0, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0x10, 0xe, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf4, + 0x0, 0xdf, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0x70, 0xa, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfa, 0x0, + 0x6f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xe0, 0x1, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0x10, 0xa, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x1, 0xdf, 0xff, + 0xff, 0xf6, 0x0, 0x2f, 0xff, 0xff, 0x80, 0x0, + 0x2, 0xcf, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x7f, + 0xff, 0xff, 0xea, 0x9c, 0xff, 0xff, 0xdd, 0xff, + 0xff, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf2, 0x6f, 0xff, 0xf4, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0xff, 0xd2, 0x0, 0xef, 0xff, + 0xa0, 0x0, 0x0, 0x17, 0xbe, 0xfe, 0xda, 0x40, + 0x0, 0x0, 0x0, 0x0, + + /* U+00AB "«" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x26, 0x66, 0x62, + 0x0, 0x0, 0x0, 0x5, 0x66, 0x65, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x7, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0x60, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0x20, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x80, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xe1, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0x40, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x1e, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0x20, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xc0, + + /* U+00AC "¬" */ + 0x26, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, + 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x65, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, + + /* U+00AD "­" */ + 0xcd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdc, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + + /* U+00AE "®" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x37, 0xac, 0xef, 0xff, 0xec, 0xa7, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x49, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xc4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4d, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x9f, + 0xff, 0xff, 0xff, 0xd9, 0x63, 0x11, 0x1, 0x25, + 0x8b, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xdf, + 0xff, 0xff, 0xf9, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x6d, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xef, + 0xff, 0xff, 0x91, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xdf, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1c, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1d, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2e, 0xff, 0xfe, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xfd, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0xdb, 0x83, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xf8, 0x0, 0x0, 0x5, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf1, 0x0, 0x0, + 0xdf, 0xff, 0x90, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x10, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0x80, 0x0, + 0x4f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xf8, 0x88, 0x88, 0x9a, 0xbe, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x0, + 0x9, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x4, 0xef, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf5, + 0x0, 0xef, 0xff, 0x30, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xa0, 0x3f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xfe, 0x7, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf2, 0xaf, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0x4c, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf7, 0xdf, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x17, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0x8f, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xf9, 0x99, 0x99, 0xaa, + 0xdf, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xf9, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x9f, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xa2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xf9, 0xef, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0x8d, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xe0, 0x0, + 0x15, 0xcf, 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xf7, 0xaf, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0x48, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf2, 0x4f, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xfe, 0x0, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xa0, + 0xb, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xf5, + 0x0, 0x5f, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0x0, 0x0, 0xef, 0xff, 0x90, 0x0, 0x0, 0x5, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0x80, 0x0, 0x7, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x5f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xf1, 0x0, 0x0, 0xe, 0xff, 0xfd, 0x0, 0x0, + 0x5, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0x90, 0x0, 0x0, 0x4f, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xfa, 0x0, + 0x0, 0x5f, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0x30, 0x0, 0x1e, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf9, + 0x0, 0x0, 0x22, 0x22, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x12, 0x22, 0x21, 0x0, 0x1d, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1c, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2d, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xef, 0xff, 0xff, 0x91, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xcf, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xdf, 0xff, 0xff, 0xf9, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4b, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xaf, 0xff, 0xff, 0xff, 0xd9, + 0x63, 0x11, 0x1, 0x24, 0x7a, 0xef, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5e, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfb, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xc4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6c, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x58, 0xbd, 0xef, 0xff, 0xec, 0xa7, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+00B0 "°" */ + 0x0, 0x0, 0x3, 0x8d, 0xef, 0xea, 0x50, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, + 0xd4, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xc8, 0x8a, 0xff, 0xff, 0xf4, 0x0, 0x8, 0xff, + 0xfe, 0x30, 0x0, 0x1, 0xaf, 0xff, 0xe0, 0x1, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x70, 0x6f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xfc, 0x9, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xf0, 0xbf, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0x1b, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xf1, 0x9f, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0x6, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xc0, 0x1f, 0xff, 0xe2, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xf7, 0x0, 0x8f, 0xff, 0xe3, 0x0, + 0x0, 0x1a, 0xff, 0xfe, 0x0, 0x0, 0xcf, 0xff, + 0xfc, 0x98, 0xaf, 0xff, 0xff, 0x40, 0x0, 0x1, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xfd, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x28, 0xdf, 0xfe, 0xa5, + 0x0, 0x0, 0x0, + + /* U+00B1 "±" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x33, + 0x33, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x26, 0x66, 0x66, 0x66, 0x66, 0x66, 0x6a, 0xff, + 0xff, 0xf6, 0x66, 0x66, 0x66, 0x66, 0x66, 0x65, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x26, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, + 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x65, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + + /* U+00B2 "²" */ + 0x0, 0x0, 0x0, 0x38, 0xbe, 0xff, 0xed, 0xb8, + 0x20, 0x0, 0x0, 0x0, 0x2, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb1, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe2, 0x0, + 0x1, 0xef, 0xff, 0xff, 0xfe, 0xde, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0xaf, 0xff, 0xfe, 0x50, 0x0, + 0x2, 0xbf, 0xff, 0xff, 0x50, 0x1f, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf9, 0x6, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xb0, 0x0, 0x24, 0x52, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xef, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfc, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2c, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xcf, 0xff, 0xff, 0xc2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xdf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xfe, 0xee, + 0xee, 0xee, 0xee, 0xee, 0xc0, 0x6f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xd, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, + + /* U+00B3 "³" */ + 0x0, 0x0, 0x5, 0xad, 0xff, 0xfe, 0xc9, 0x50, + 0x0, 0x0, 0x0, 0x4, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x60, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x2, 0xff, + 0xff, 0xff, 0xb9, 0xad, 0xff, 0xff, 0xff, 0x20, + 0xb, 0xff, 0xff, 0xc1, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0x80, 0x2f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xa0, 0x2, 0x57, 0xa4, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x38, 0xae, + 0xff, 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xd7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xfa, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x6d, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xfc, 0x68, 0xab, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xfc, 0xbf, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfa, 0x5f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf5, + 0xd, 0xff, 0xff, 0xfb, 0x64, 0x58, 0xef, 0xff, + 0xff, 0xc0, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x20, 0x0, 0x3d, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc2, 0x0, 0x0, 0x0, + 0x7d, 0xff, 0xff, 0xff, 0xff, 0xc6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x14, 0x67, 0x76, 0x41, 0x0, + 0x0, 0x0, + + /* U+00B5 "µ" */ + 0x13, 0x33, 0x33, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x13, 0x33, 0x33, 0x7, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf2, 0x7f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x27, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf2, 0x7f, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0x27, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf2, 0x7f, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0x27, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf2, 0x7f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x27, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf2, 0x7f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x27, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf2, 0x7f, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x27, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf2, 0x7f, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x27, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf2, + 0x7f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x27, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xf2, 0x7f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0x27, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xf2, 0x7f, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0x27, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf2, 0x7f, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0x27, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xf2, 0x7f, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0x27, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xf2, 0x7f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0x27, + 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xf2, 0x7f, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0xff, 0x27, 0xff, 0xff, 0xff, + 0xff, 0xd3, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xff, 0xf2, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xfb, 0x75, 0x46, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x27, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xf2, + 0x7f, 0xff, 0xff, 0x6f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x2f, 0xff, 0xff, 0x27, 0xff, + 0xff, 0xf4, 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x20, 0xff, 0xff, 0xf2, 0x7f, 0xff, 0xff, + 0x40, 0x2b, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x10, + 0xf, 0xff, 0xff, 0x27, 0xff, 0xff, 0xf4, 0x0, + 0x3, 0x9d, 0xff, 0xec, 0x83, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00B6 "¶" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x46, 0x78, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x99, 0x99, 0x40, 0x0, 0x0, 0x0, 0x3, 0x9d, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x3b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x9, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xe0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x9, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x9, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x16, 0xad, 0xff, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x9, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x9, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x9, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x9, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, 0x0, 0x0, + 0x0, + + /* U+00B7 "·" */ + 0x9, 0x99, 0x99, 0x95, 0x1f, 0xff, 0xff, 0xf8, + 0x1f, 0xff, 0xff, 0xf8, 0x1f, 0xff, 0xff, 0xf8, + 0x1f, 0xff, 0xff, 0xf8, 0x1f, 0xff, 0xff, 0xf8, + 0x1f, 0xff, 0xff, 0xf8, + + /* U+00BB "»" */ + 0x16, 0x66, 0x63, 0x0, 0x0, 0x0, 0x4, 0x66, + 0x66, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x50, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xe1, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0x30, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0xef, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+00BD "½" */ + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xef, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2a, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xfe, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf6, 0x5f, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xa1, 0x5, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xe8, 0x10, + 0x0, 0x5f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x10, + 0x0, 0x0, 0x5, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x66, 0x66, 0x20, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x8b, 0xef, 0xfe, 0xdb, 0x82, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x2b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, 0xed, 0xef, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xe6, 0x0, + 0x0, 0x2a, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x35, 0x20, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2e, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xcf, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1c, + 0xff, 0xff, 0xfd, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1d, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1d, 0xff, 0xff, 0xe2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xee, + 0xee, 0xee, 0xee, 0xee, 0xec, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x9, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe0, 0x0, 0x4, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+0384 "΄" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xe2, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xfd, 0x10, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x9, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, + + /* U+0386 "Ά" */ + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0x50, 0x0, 0x0, 0xf, 0xff, 0xff, 0xbf, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0x3f, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xfb, 0xe, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xf7, 0x9, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf3, 0x3, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xe0, 0x0, 0xef, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x90, + 0x0, 0x8f, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0x40, 0x0, + 0x2f, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xfe, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xc1, 0x11, 0x11, 0x11, + 0x11, 0x11, 0x11, 0x11, 0x9f, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xfe, 0x0, 0x4, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0x50, 0xa, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0xc0, 0x7, 0x88, 0x88, 0x85, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x78, 0x88, 0x88, 0x70, + + /* U+0388 "Έ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf9, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x10, 0x0, 0xc, + 0xff, 0xff, 0xfe, 0x10, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x10, + 0x0, 0x4f, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x10, 0x0, 0xbf, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x10, 0x3, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x98, + 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, + 0x88, 0x88, 0x88, 0x88, 0x88, 0x0, 0xb, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x98, + 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, + 0x88, 0x88, 0x88, 0x88, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xa9, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x91, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + + /* U+0389 "Ή" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xfa, + 0x0, 0x6f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xfa, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x6f, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xfa, 0x0, 0xc, + 0xff, 0xff, 0xfe, 0x20, 0x0, 0x6f, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfa, + 0x0, 0x3f, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xfa, 0x0, 0xbf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xfa, 0x2, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xfa, 0xa, 0xff, + 0xff, 0xd1, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfa, + 0x2f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xfa, 0x9f, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xf9, 0x99, 0x99, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x9d, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfa, + + /* U+038A "Ί" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, + 0xa0, 0x6, 0xff, 0xff, 0xfd, 0x0, 0x4, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0x6f, 0xff, 0xff, 0xd0, + 0x0, 0xcf, 0xff, 0xff, 0xe2, 0x0, 0x6, 0xff, + 0xff, 0xfd, 0x0, 0x3f, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xd0, 0xb, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x6, 0xff, 0xff, 0xfd, 0x2, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xd0, 0xaf, 0xff, 0xfd, 0x10, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xfd, 0x2f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xd9, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xfd, + + /* U+038C "Ό" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x48, 0xad, 0xef, 0xff, 0xec, + 0xa8, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x5, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xa4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x6, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xfe, 0x10, 0x0, 0x3, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x70, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, 0x76, + 0x66, 0x8a, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xfd, 0x71, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x7e, 0xff, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xd0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xfe, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x20, 0x0, 0x5f, 0xff, 0xff, + 0xff, 0xb1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xdf, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0xaf, 0xff, 0xf5, 0x0, 0x1, 0xef, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1c, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xdf, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xdf, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xfe, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xfc, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x7e, 0xff, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xc9, 0x76, 0x56, 0x7a, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xdf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xa4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x47, 0xad, 0xef, 0xff, 0xec, + 0xa7, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+038E "Ύ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x6f, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0xf3, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xff, 0x20, 0x0, 0xb, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x3, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0xbf, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xff, 0xe1, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0xa, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xff, 0xff, 0x40, 0x0, 0x3, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf7, + 0x0, 0x7f, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xff, 0xe1, 0x1f, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0x9a, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+038F "Ώ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x58, 0xbd, 0xef, 0xfe, 0xdc, + 0x96, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x6, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x81, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x6, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x91, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xfe, + 0x10, 0x0, 0x2, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0x70, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc9, 0x76, 0x56, 0x8c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, + 0xfe, 0x71, 0x0, 0x0, 0x0, 0x0, 0x16, 0xef, + 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xd0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x20, 0x0, 0x1e, 0xff, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0xaf, 0xff, 0xf5, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xfd, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xfc, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2d, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x59, 0x99, 0x99, + 0x99, 0x99, 0xcf, 0xff, 0xff, 0xfe, 0x60, 0x0, + 0x0, 0x5, 0xef, 0xff, 0xff, 0xfc, 0x99, 0x99, + 0x99, 0x99, 0x95, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + + /* U+0390 "ΐ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x48, 0x88, + 0x88, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0xef, 0xff, 0xf4, 0x8, 0xff, + 0xff, 0xf0, 0x6f, 0xff, 0xff, 0x30, 0x0, 0x6f, + 0xff, 0xf8, 0x0, 0x8f, 0xff, 0xff, 0x6, 0xff, + 0xff, 0xf3, 0x0, 0xe, 0xff, 0xfc, 0x0, 0x8, + 0xff, 0xff, 0xf0, 0x6f, 0xff, 0xff, 0x30, 0x6, + 0xff, 0xfe, 0x10, 0x0, 0x8f, 0xff, 0xff, 0x6, + 0xff, 0xff, 0xf3, 0x0, 0xef, 0xff, 0x50, 0x0, + 0x8, 0xff, 0xff, 0xf0, 0x6f, 0xff, 0xff, 0x30, + 0x6f, 0xff, 0x90, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0x1, 0x33, 0x33, 0x30, 0x2, 0x33, 0x30, 0x0, + 0x0, 0x1, 0x33, 0x33, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0x33, 0x33, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0391 "Α" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xbf, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0x3f, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xfb, 0xe, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xf7, 0x9, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf3, 0x3, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xe0, 0x0, 0xef, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x90, + 0x0, 0x8f, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0x40, 0x0, + 0x2f, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xfe, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xc1, 0x11, 0x11, 0x11, + 0x11, 0x11, 0x11, 0x11, 0x9f, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xfe, 0x0, 0x4, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0x50, 0xa, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0xc0, 0x7, 0x88, 0x88, 0x85, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x78, 0x88, 0x88, 0x70, + + /* U+0392 "Β" */ + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xed, 0xb8, 0x51, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd3, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xa9, 0x99, 0x99, 0x99, 0x99, 0x99, 0xac, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0x9f, 0xff, 0xff, 0xff, 0xd0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2d, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xfb, 0x0, 0x2, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf0, + 0x0, 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0x10, 0x2, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf3, 0x0, 0x2f, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0x30, + 0x2, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf1, 0x0, 0x2f, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xfe, 0x0, 0x2, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x90, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, + 0xf3, 0x0, 0x2, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1c, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0x9f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xa9, 0x99, 0x99, 0x99, 0x99, + 0x99, 0xab, 0xdf, 0xff, 0xff, 0xff, 0xfd, 0x10, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x20, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x11, 0x35, 0x8c, 0xff, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x9f, 0xff, + 0xff, 0xff, 0x80, 0x2, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0x20, 0x2f, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfa, + 0x2, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xf0, 0x2f, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0x32, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf6, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x72, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf8, 0x2f, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x62, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xf5, 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0x22, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xe0, 0x2f, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xf9, 0x2, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xbf, + 0xff, 0xff, 0xff, 0x20, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x49, 0xff, 0xff, 0xff, 0xff, 0x90, 0x2, 0xff, + 0xff, 0xff, 0xa9, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x9a, 0xbd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, + 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe2, 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x91, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe8, 0x20, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xdb, 0x96, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0393 "Γ" */ + 0x69, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x97, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x58, 0x88, 0x88, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0394 "Δ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0x88, 0x88, 0x87, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xef, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0x7f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xfd, 0x1f, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xf9, 0xc, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xf5, 0x7, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xf1, 0x1, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xb0, + 0x0, 0xcf, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x60, 0x0, + 0x6f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xff, 0x10, 0x0, 0x1f, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xfc, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xfd, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x9a, + 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x0, 0x1, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x20, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x80, 0xd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, + + /* U+0395 "Ε" */ + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x60, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x60, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x60, 0xcf, 0xff, 0xff, 0xc9, 0x99, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x99, 0x99, 0x99, 0x30, 0xcf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x90, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x90, 0x0, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x90, 0x0, 0xcf, 0xff, 0xff, 0xc8, 0x88, 0x88, + 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, + 0x88, 0x88, 0x50, 0x0, 0xcf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xc9, 0x99, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x99, 0x99, 0x99, 0x94, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf7, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, + + /* U+0396 "Ζ" */ + 0x0, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x1f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x1f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x9, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x9f, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xdf, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, + 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xfd, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xfd, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x95, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf8, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf8, + + /* U+0397 "Η" */ + 0x24, 0x44, 0x44, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0x44, 0x44, 0x41, 0xbf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, + 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, + 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf5, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, 0xc9, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x99, 0x99, 0x9f, 0xff, 0xff, 0xf5, 0xbf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, + 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, + 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, + + /* U+0398 "Θ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x37, 0xac, 0xef, 0xff, 0xed, 0xb8, 0x51, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x9e, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xea, 0x86, 0x66, 0x79, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xff, 0xff, 0x82, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x6c, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5e, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xd3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xbf, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xfc, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xf3, 0x0, 0x4, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xfa, + 0x0, 0x9, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0x0, + 0xd, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0x40, 0x1f, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x80, 0x5f, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xb0, 0x7f, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xe0, 0x9f, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xf0, 0xbf, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xf2, 0xdf, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xf3, 0xdf, 0xff, 0xff, 0x90, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf3, + 0xef, 0xff, 0xff, 0x90, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf4, 0xef, + 0xff, 0xff, 0x80, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf3, 0xdf, 0xff, + 0xff, 0x90, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xf3, 0xcf, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x5, 0x88, 0x88, 0x88, 0x88, + 0x88, 0x88, 0x88, 0x88, 0x88, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xf2, 0xaf, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xf0, 0x8f, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xe0, 0x5f, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xb0, 0x1f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x80, + 0xd, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x40, 0x8, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0x0, 0x3, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xfc, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, 0xd2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4e, 0xff, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xfe, 0x71, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6c, 0xff, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, 0x76, + 0x56, 0x79, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0x8e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xb6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x36, 0xac, 0xde, 0xff, 0xed, 0xb8, 0x51, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0399 "Ι" */ + 0x34, 0x44, 0x44, 0x1f, 0xff, 0xff, 0xf5, 0xff, + 0xff, 0xff, 0x5f, 0xff, 0xff, 0xf5, 0xff, 0xff, + 0xff, 0x5f, 0xff, 0xff, 0xf5, 0xff, 0xff, 0xff, + 0x5f, 0xff, 0xff, 0xf5, 0xff, 0xff, 0xff, 0x5f, + 0xff, 0xff, 0xf5, 0xff, 0xff, 0xff, 0x5f, 0xff, + 0xff, 0xf5, 0xff, 0xff, 0xff, 0x5f, 0xff, 0xff, + 0xf5, 0xff, 0xff, 0xff, 0x5f, 0xff, 0xff, 0xf5, + 0xff, 0xff, 0xff, 0x5f, 0xff, 0xff, 0xf5, 0xff, + 0xff, 0xff, 0x5f, 0xff, 0xff, 0xf5, 0xff, 0xff, + 0xff, 0x5f, 0xff, 0xff, 0xf5, 0xff, 0xff, 0xff, + 0x5f, 0xff, 0xff, 0xf5, 0xff, 0xff, 0xff, 0x5f, + 0xff, 0xff, 0xf5, 0xff, 0xff, 0xff, 0x5f, 0xff, + 0xff, 0xf5, 0xff, 0xff, 0xff, 0x5f, 0xff, 0xff, + 0xf5, 0xff, 0xff, 0xff, 0x5f, 0xff, 0xff, 0xf5, + 0xff, 0xff, 0xff, 0x5f, 0xff, 0xff, 0xf5, 0xff, + 0xff, 0xff, 0x5f, 0xff, 0xff, 0xf5, 0xff, 0xff, + 0xff, 0x5f, 0xff, 0xff, 0xf5, 0xff, 0xff, 0xff, + 0x5f, 0xff, 0xff, 0xf5, 0xff, 0xff, 0xff, 0x5f, + 0xff, 0xff, 0xf5, 0xff, 0xff, 0xff, 0x5f, 0xff, + 0xff, 0xf5, 0xff, 0xff, 0xff, 0x5f, 0xff, 0xff, + 0xf5, 0xff, 0xff, 0xff, 0x5f, 0xff, 0xff, 0xf5, + + /* U+039A "Κ" */ + 0x4, 0x44, 0x44, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x24, + 0x44, 0x44, 0x44, 0x30, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0x40, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xfe, 0x30, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, + 0xe3, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xfd, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0xc1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0xfc, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x3f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf5, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7d, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf6, 0x2, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0x20, + 0x2f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0xc0, 0x2f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xf8, + + /* U+039B "Λ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x28, 0x88, 0x88, 0x82, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xfc, 0xcf, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xf7, 0x7f, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xf3, 0x2f, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xe0, 0xd, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x80, 0x8, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0x30, 0x3, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xfd, 0x0, 0x0, 0xdf, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xc0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0xef, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfd, 0x0, + 0x4, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0x30, 0xa, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0x90, 0x1f, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xf0, 0x7f, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf6, + + /* U+039C "Μ" */ + 0x4, 0x44, 0x44, 0x44, 0x44, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x44, 0x44, 0x44, 0x44, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xf0, 0xf, + 0xff, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xff, 0xff, 0x0, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xff, 0xf0, 0xf, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0x0, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xff, 0xff, 0xf0, 0xf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x0, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xf0, 0xf, 0xff, 0xff, 0xfc, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x0, 0xff, 0xff, 0xff, 0x6f, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xaf, + 0xff, 0xff, 0xf0, 0xf, 0xff, 0xff, 0xf1, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf4, 0xff, + 0xff, 0xff, 0x0, 0xff, 0xff, 0xff, 0xc, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xfe, 0xf, 0xff, + 0xff, 0xf0, 0xf, 0xff, 0xff, 0xf0, 0x6f, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0x90, 0xff, 0xff, + 0xff, 0x0, 0xff, 0xff, 0xff, 0x1, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xf4, 0xf, 0xff, 0xff, + 0xf0, 0xf, 0xff, 0xff, 0xf0, 0xb, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xfe, 0x0, 0xff, 0xff, 0xff, + 0x0, 0xff, 0xff, 0xff, 0x0, 0x6f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0x90, 0xf, 0xff, 0xff, 0xf0, + 0xf, 0xff, 0xff, 0xf0, 0x1, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xf3, 0x0, 0xff, 0xff, 0xff, 0x0, + 0xff, 0xff, 0xff, 0x0, 0xb, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xfd, 0x0, 0xf, 0xff, 0xff, 0xf0, 0xf, + 0xff, 0xff, 0xf0, 0x0, 0x5f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0x80, 0x0, 0xff, 0xff, 0xff, 0x0, 0xff, + 0xff, 0xff, 0x0, 0x0, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xf2, 0x0, 0xf, 0xff, 0xff, 0xf0, 0xf, 0xff, + 0xff, 0xf0, 0x0, 0xb, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfd, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x0, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0x70, + 0x0, 0xf, 0xff, 0xff, 0xf0, 0xf, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf2, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x0, 0xff, 0xff, 0xff, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xfc, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf0, 0xf, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0x70, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x0, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xf1, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf0, 0xf, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x0, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0x60, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf0, 0xf, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xf1, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x0, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf0, 0xf, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x9, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x0, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xfa, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf0, + 0xf, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x4f, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x0, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0x50, 0x0, 0xa, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf0, 0xf, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xfa, 0x0, 0x0, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x0, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xf0, 0x0, 0x5f, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf0, 0xf, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0x40, 0xa, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x0, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xf9, 0x0, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf0, 0xf, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xe0, 0x5f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x0, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0x4a, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf0, 0xf, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf9, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x0, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf0, 0xf, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x0, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf0, 0xf, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x0, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf0, 0xf, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x0, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf0, + + /* U+039D "Ν" */ + 0x34, 0x44, 0x44, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x44, 0x44, 0x41, 0xcf, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf7, 0xcf, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf7, 0xcf, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf7, 0xcf, + 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf7, 0xcf, 0xff, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf7, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf7, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf7, 0xcf, 0xff, 0xff, 0x9f, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, 0x3b, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf7, 0xcf, + 0xff, 0xff, 0x31, 0xef, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf7, 0xcf, 0xff, 0xff, 0x30, 0x5f, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, + 0x30, 0xb, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf7, + 0xcf, 0xff, 0xff, 0x30, 0x1, 0xef, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, 0x30, 0x0, + 0x5f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf7, 0xcf, 0xff, + 0xff, 0x30, 0x0, 0xa, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf7, 0xcf, 0xff, 0xff, 0x30, 0x0, 0x1, 0xef, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf7, 0xcf, + 0xff, 0xff, 0x30, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf7, 0xcf, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf7, + 0xcf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf7, 0xcf, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf7, 0xcf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf7, 0xcf, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf7, 0xcf, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x8, 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xff, 0xff, 0xf3, 0x0, 0x8, 0xff, 0xff, 0xf7, + 0xcf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xfd, 0x0, 0x8, + 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0x80, 0x8, 0xff, 0xff, 0xf7, 0xcf, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xff, 0xf3, 0x8, 0xff, 0xff, + 0xf7, 0xcf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xfd, + 0x8, 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0x88, 0xff, 0xff, 0xf7, 0xcf, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xfc, 0xff, + 0xff, 0xf7, 0xcf, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, + 0xcf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xcf, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, + 0xf7, 0xcf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xff, 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xf7, 0xcf, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xf7, 0xcf, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf7, + + /* U+039E "Ξ" */ + 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x80, 0x9, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x80, 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x59, 0x99, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x58, 0x88, 0x88, 0x88, + 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, + 0x88, 0x88, 0x40, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x93, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x67, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x67, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf6, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, + + /* U+039F "Ο" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x37, 0xac, 0xef, 0xff, 0xed, 0xb8, 0x51, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x9e, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xea, 0x86, 0x66, 0x79, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xff, 0xff, 0x82, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x6c, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5e, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xd3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xbf, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xfc, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xf3, 0x0, 0x4, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xfa, + 0x0, 0x9, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0x0, + 0xd, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0x40, 0x1f, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x80, 0x5f, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xb0, 0x7f, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xe0, 0x9f, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xf0, 0xbf, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xf2, 0xdf, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xf3, 0xdf, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf3, + 0xef, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf4, 0xef, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf3, 0xdf, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xf3, 0xcf, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xf2, 0xaf, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xf0, 0x8f, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xe0, 0x5f, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xb0, 0x1f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x80, + 0xd, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x40, 0x8, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0x0, 0x3, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xfc, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, 0xd2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4e, 0xff, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xfe, 0x71, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6c, 0xff, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, 0x76, + 0x56, 0x79, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0x8e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xb6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x36, 0xac, 0xde, 0xff, 0xed, 0xb8, 0x51, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A0 "Π" */ + 0x69, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x99, 0x99, 0x93, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf5, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, + 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, + 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, + 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, + 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, + 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0xbf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xf5, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xf5, 0x58, 0x88, 0x88, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0x88, 0x88, 0x82, + + /* U+03A1 "Ρ" */ + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0xcb, 0x96, 0x30, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x30, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd1, + 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0xe, 0xff, 0xff, 0xfb, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0xac, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, 0xef, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x17, 0xff, 0xff, 0xff, 0xff, + 0x50, 0xe, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, + 0xff, 0xff, 0xfd, 0x0, 0xef, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xff, 0xf4, 0xe, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0x90, 0xef, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xfd, 0xe, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf0, 0xef, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, + 0x1e, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xf2, 0xef, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0x1e, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf0, + 0xef, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xfe, 0xe, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0xa0, 0xef, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf6, 0xe, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xff, 0x10, 0xef, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xff, 0x80, 0xe, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x27, 0xdf, 0xff, 0xff, 0xff, 0xf1, 0x0, 0xef, + 0xff, 0xff, 0xb9, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x99, 0xac, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd4, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x50, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xec, 0xa8, + 0x41, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A3 "Σ" */ + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe0, 0x3, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x3, + 0xff, 0xff, 0xff, 0xe9, 0x99, 0x99, 0x99, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x98, + 0x0, 0x1e, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xfd, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfe, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xe2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xfe, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xe9, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x92, 0x3f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x33, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf3, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x33, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf3, 0x3f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, + + /* U+03A4 "Τ" */ + 0x59, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x99, 0x99, 0x97, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x9f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x88, 0x88, 0x88, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A5 "Υ" */ + 0x58, 0x88, 0x88, 0x87, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x78, 0x88, 0x88, 0x82, 0x2f, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xc0, 0x7, 0xff, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xff, 0x20, 0x0, 0xcf, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xfe, 0x10, 0x1, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x90, 0xa, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xf2, 0x4f, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xfb, 0xdf, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A6 "Φ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0x55, 0x55, 0x52, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x2d, 0xff, 0xff, 0xf8, 0x21, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x6a, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0xc9, 0x51, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xa1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x95, 0x31, 0xc, 0xff, 0xff, 0xf7, 0x12, 0x37, + 0xbe, 0xff, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, 0xfb, 0x30, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x6e, 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xfe, 0x40, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xd1, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0x60, + 0x0, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xc0, + 0x5, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, + 0xa, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf6, + 0xd, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf9, + 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xfb, + 0x2f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xfd, + 0x3f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xfe, + 0x4f, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xfe, + 0x3f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xfd, + 0x2f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xfc, + 0xf, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xfa, + 0xe, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf8, + 0xa, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf4, + 0x6, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf0, + 0x0, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x9f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x2f, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xb1, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x1, 0xbf, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x1d, 0xff, 0xff, 0xff, 0xff, 0x92, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x2, 0x9f, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xd9, 0x64, 0x3d, 0xff, 0xff, 0xf9, 0x45, 0x69, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1c, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x9e, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x36, + 0x9c, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xdb, + 0x85, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A7 "Χ" */ + 0x0, 0x14, 0x44, 0x44, 0x43, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0x44, 0x44, 0x44, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xff, 0xff, 0x40, 0x0, 0x9f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xe0, 0x5, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xf9, 0x1e, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0xbf, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xf9, 0xbf, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, + 0xe1, 0x2f, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0x50, 0x6, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xe1, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xfc, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0x80, 0x5f, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xf4, + + /* U+03A8 "Ψ" */ + 0x34, 0x44, 0x44, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x24, 0x44, 0x44, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0x44, 0x44, 0x40, + 0xef, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf0, + 0xef, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf0, + 0xef, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf0, + 0xef, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf0, + 0xef, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf0, + 0xef, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf0, + 0xef, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf0, + 0xef, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf0, + 0xef, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf0, + 0xef, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf0, + 0xef, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf0, + 0xef, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf0, + 0xef, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf0, + 0xef, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf0, + 0xef, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf0, + 0xdf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf0, + 0xcf, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xd0, + 0xaf, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xb0, + 0x7f, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x90, + 0x4f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0x50, + 0xf, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0x10, + 0xa, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xfc, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xfc, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0xe4, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x3, 0xdf, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xc5, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x3, 0xaf, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xea, + 0x63, 0x10, 0x9f, 0xff, 0xff, 0xb0, 0x12, 0x59, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xd1, 0x0, 0x0, + 0x0, 0x0, 0x1d, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xdf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x7b, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xeb, 0x73, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x24, 0x55, 0xbf, 0xff, 0xff, 0xc5, 0x54, 0x21, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A9 "Ω" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0x69, 0xcd, 0xef, 0xfe, 0xdb, 0x86, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x18, 0xdf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x19, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb8, + 0x65, 0x67, 0x9d, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xff, 0xfc, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x29, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2c, 0xff, 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xd2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xf4, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xf9, 0x0, 0x7, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xfd, 0x0, + 0xb, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0x10, 0xe, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0x40, 0x1f, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0x70, 0x3f, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x90, + 0x4f, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xa0, 0x5f, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xa0, 0x5f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xb0, 0x4f, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xa0, + 0x4f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x90, 0x2f, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x80, 0xf, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0x60, 0xd, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, + 0xa, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0x0, 0x5, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xfb, 0x0, 0x1, 0xff, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xef, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xb1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xfe, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x2a, 0xff, 0xff, 0xfd, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x89, 0x99, 0x99, 0x99, + 0x99, 0xef, 0xff, 0xff, 0xfc, 0x30, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xfa, 0x99, 0x99, 0x99, + 0x99, 0x92, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf4, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + + /* U+03AA "Ϊ" */ + 0x9, 0x99, 0x99, 0x90, 0x0, 0x0, 0x9, 0x99, + 0x99, 0x90, 0xf, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf0, 0xf, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf0, 0xf, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf0, + 0xf, 0xff, 0xff, 0xf0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf0, 0xf, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf0, 0xf, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x44, 0x44, + 0x41, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, + + /* U+03AB "Ϋ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x19, 0x99, + 0x99, 0x80, 0x0, 0x0, 0x19, 0x99, 0x99, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x12, 0x22, + 0x22, 0x21, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x12, 0x22, 0x22, 0x20, 0x6f, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xf1, 0xb, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0x50, + 0x1, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xe1, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0xef, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0x70, 0x8, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xe1, 0x2f, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xf9, 0xbf, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03AC "ά" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x37, 0xab, 0xcc, 0xb8, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7d, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x91, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x3d, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x40, 0x0, 0xb, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, 0xf, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, 0x5f, + 0xff, 0xff, 0xa0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xff, 0xa4, 0x20, 0x13, 0x8e, 0xff, 0xff, 0xf2, + 0xaf, 0xff, 0xff, 0x50, 0x0, 0xd, 0xff, 0xff, + 0xff, 0xd2, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xfc, 0xef, 0xff, 0xff, 0x10, 0x0, 0x7f, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, 0xef, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x4, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, 0xf5, 0x0, + 0xa, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xf1, + 0x0, 0xe, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xe0, 0x0, 0x1f, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xa0, 0x0, 0x5f, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0x70, 0x0, 0x7f, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0x30, 0x0, 0x8f, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xfd, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfa, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xf9, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfc, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0x20, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x50, 0x0, 0x1f, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x80, 0x0, 0xe, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xc0, 0x0, 0xa, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x1, 0xaf, 0xff, 0xf9, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xfd, 0x50, 0x0, 0x1, 0x7e, 0xff, 0xff, + 0xf1, 0xcf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xff, 0xff, 0xec, 0xef, 0xff, 0xff, + 0xff, 0x70, 0x7f, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x2f, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x90, 0x0, 0xc, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x1, 0x9f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd5, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x1, 0x6a, 0xdf, + 0xff, 0xeb, 0x83, 0x0, 0x0, 0x0, 0x0, 0x33, + 0x33, 0x32, + + /* U+03AD "έ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0x7b, 0xde, 0xff, 0xdb, 0x83, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3c, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd3, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0xc, 0xff, + 0xff, 0xff, 0x72, 0x0, 0x26, 0xbf, 0xff, 0xff, + 0xfa, 0x0, 0x3, 0xff, 0xff, 0xfe, 0x20, 0x0, + 0x0, 0x0, 0x2a, 0xff, 0xf7, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xd4, 0x0, 0x0, 0xc, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xfd, 0x62, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xed, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xfd, 0x74, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0x60, 0x0, 0x6f, 0xff, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1c, 0xff, + 0x90, 0x1, 0xff, 0xff, 0xff, 0xc1, 0x0, 0x0, + 0x0, 0x0, 0x5e, 0xff, 0xff, 0xb0, 0x9, 0xff, + 0xff, 0xff, 0xe6, 0x0, 0x0, 0x15, 0xcf, 0xff, + 0xff, 0xff, 0xa0, 0x1e, 0xff, 0xff, 0xff, 0xff, + 0xdc, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xd1, 0x0, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x3e, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x50, 0x0, + 0x0, 0x0, 0x19, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x69, 0xde, 0xff, 0xed, 0xb7, 0x30, 0x0, 0x0, + 0x0, + + /* U+03AE "ή" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x13, 0x33, 0x32, 0x0, 0x0, + 0x2, 0x7b, 0xef, 0xff, 0xec, 0x83, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xb0, 0x0, 0x2b, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x40, 0x0, 0x0, + 0x8f, 0xff, 0xfb, 0x0, 0x6f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x8, 0xff, + 0xff, 0xb0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x8f, 0xff, 0xfb, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x70, 0x8, 0xff, 0xff, 0xef, 0xff, + 0xff, 0xc6, 0x21, 0x1, 0x48, 0xff, 0xff, 0xff, + 0xff, 0x10, 0x8f, 0xff, 0xff, 0xff, 0xfe, 0x40, + 0x0, 0x0, 0x0, 0x1, 0xcf, 0xff, 0xff, 0xf7, + 0x8, 0xff, 0xff, 0xff, 0xfc, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xb0, 0x8f, + 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xfe, 0x8, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf0, 0x8f, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0x28, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xf3, 0x8f, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x48, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x8f, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x48, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf4, 0x8f, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x48, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, + 0x8f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x48, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf4, 0x8f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x48, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf4, 0x8f, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0x48, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x8f, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0x48, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf4, 0x8f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x48, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf4, 0x8f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x48, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x8f, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x48, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf4, 0x8f, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x48, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, + 0x8f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf4, + + /* U+03AF "ί" */ + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xfd, 0x10, 0x0, + 0xe, 0xff, 0xff, 0xff, 0x30, 0x0, 0x7, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0xef, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0x33, 0x33, 0x30, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + + /* U+03B0 "ΰ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x68, + 0x88, 0x87, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0x0, 0x0, + 0x3f, 0xff, 0xfe, 0x10, 0xcf, 0xff, 0xfd, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0x0, 0x0, 0xaf, 0xff, + 0xf4, 0x0, 0xcf, 0xff, 0xfd, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0x0, 0x2, 0xff, 0xff, 0x80, 0x0, + 0xcf, 0xff, 0xfd, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0x0, 0xa, 0xff, 0xfc, 0x0, 0x0, 0xcf, 0xff, + 0xfd, 0x0, 0x0, 0xaf, 0xff, 0xff, 0x0, 0x2f, + 0xff, 0xf2, 0x0, 0x0, 0xcf, 0xff, 0xfd, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0x0, 0x9f, 0xff, 0x50, + 0x0, 0x0, 0xcf, 0xff, 0xfd, 0x0, 0x0, 0x13, + 0x33, 0x32, 0x0, 0x23, 0x32, 0x0, 0x0, 0x0, + 0x23, 0x33, 0x32, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x35, 0x55, 0x55, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x55, + 0x55, 0x54, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfb, + 0x9f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xfa, 0x8f, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xf9, 0x6f, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xf8, 0x4f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, + 0x1f, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xf1, 0xd, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xd0, 0x7, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0x60, 0x1, 0xff, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x3e, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xff, 0xb3, 0x0, 0x0, + 0x29, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0xde, 0xff, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2a, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x92, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x16, 0xad, 0xef, 0xfe, 0xc9, 0x51, + 0x0, 0x0, 0x0, 0x0, + + /* U+03B1 "α" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x37, 0xab, 0xcc, + 0xb8, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7d, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x91, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x3d, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0x40, 0x0, 0xb, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, + 0xf, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x40, 0x5f, 0xff, 0xff, 0xa0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0xff, 0xa4, 0x20, 0x13, 0x8e, 0xff, + 0xff, 0xf2, 0xaf, 0xff, 0xff, 0x50, 0x0, 0xd, + 0xff, 0xff, 0xff, 0xd2, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xfc, 0xef, 0xff, 0xff, 0x10, 0x0, + 0x7f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0xef, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x4, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0xa, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xf1, 0x0, 0xe, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0xe0, 0x0, 0x1f, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xa0, 0x0, 0x5f, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0x70, 0x0, 0x7f, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0x30, 0x0, 0x8f, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xfd, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfa, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xf9, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xfc, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0x20, 0x0, 0x5f, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0x50, 0x0, 0x1f, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x80, 0x0, + 0xe, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0xa, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x1, 0xaf, + 0xff, 0xf9, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xfd, 0x50, 0x0, 0x1, 0x7e, + 0xff, 0xff, 0xf1, 0xcf, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xec, 0xef, + 0xff, 0xff, 0xff, 0x70, 0x7f, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0x0, 0x2f, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0xc, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x1, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd5, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x6a, 0xdf, 0xff, 0xeb, 0x83, 0x0, 0x0, 0x0, + 0x0, 0x33, 0x33, 0x32, + + /* U+03B2 "β" */ + 0x0, 0x0, 0x0, 0x0, 0x1, 0x69, 0xce, 0xff, + 0xec, 0xa6, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3b, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xa2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0xcd, 0xff, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xff, 0xff, 0xfc, 0x50, 0x0, 0x0, 0x39, 0xff, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x3, 0xdf, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xff, 0xff, 0x30, 0x0, 0x8, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0xdf, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xd0, 0x0, 0x1f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0x0, 0x3, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xf1, 0x0, 0x5f, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0x0, 0x6, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf0, + 0x0, 0x7f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfc, 0x0, + 0x7, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x70, 0x0, + 0x7f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xe0, 0x0, 0x7, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2b, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x12, 0x58, 0xdf, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0x40, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc2, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xe8, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0x40, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xeb, + 0x71, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0x10, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x40, + 0x0, 0x2, 0x34, 0x46, 0x8c, 0xff, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x7, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x7e, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x7f, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1c, 0xff, 0xff, + 0xff, 0x40, 0x7, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xfe, 0x10, 0x7f, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xf9, 0x7, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xf1, 0x7f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0x57, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf9, + 0x7f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xc7, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xfe, 0x7f, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf7, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xfe, 0x7f, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xc7, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xfb, 0x7f, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0x77, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xf2, 0x7f, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xfc, 0x7, 0xff, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0x50, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, + 0xff, 0xc0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x91, 0x0, 0x0, 0x0, 0x5, 0xef, 0xff, 0xff, + 0xf2, 0x0, 0x7f, 0xff, 0xff, 0x7f, 0xff, 0xff, + 0xfb, 0x75, 0x46, 0x8d, 0xff, 0xff, 0xff, 0xf6, + 0x0, 0x7, 0xff, 0xff, 0xf4, 0x4f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0x40, 0x3e, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf4, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xa2, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x59, 0xce, + 0xff, 0xed, 0xa6, 0x10, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+03B3 "γ" */ + 0x8, 0x88, 0x88, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x68, 0x88, 0x88, + 0x0, 0xdf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xd0, 0x7, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xf7, 0x0, 0x1f, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0x10, 0x0, 0xbf, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xb0, 0x0, 0x5, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0x0, 0x0, 0xf, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xf5, 0x0, 0x5, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xa0, 0x0, 0xbf, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0x0, 0x1f, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xf6, 0x6, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xb0, 0xcf, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0x4f, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xfe, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03B4 "δ" */ + 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xfd, + 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, + 0xb4, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xcf, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xfd, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3e, 0xff, 0xff, 0xff, 0xa1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1c, 0xff, 0xff, 0xff, + 0xe4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x5d, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, 0xc7, + 0x31, 0x1, 0x38, 0xef, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xfe, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xf7, 0x0, 0x4, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xe0, 0x0, 0xaf, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0x50, 0xf, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xfa, 0x3, 0xff, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xe0, 0x5f, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x17, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf4, 0x9f, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0x5a, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf5, 0xaf, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x69, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf6, + 0x8f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0x57, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xf3, 0x4f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0x11, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xe0, 0xd, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xfb, 0x0, 0x8f, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0x60, 0x2, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xf1, 0x0, 0xb, 0xff, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1d, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, 0x0, 0x4e, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xff, 0xa4, 0x0, 0x0, 0x4, 0xbf, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xec, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5c, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe8, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x7a, 0xde, 0xff, + 0xfd, 0xb8, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03B5 "ε" */ + 0x0, 0x0, 0x0, 0x3, 0x7b, 0xde, 0xff, 0xdb, + 0x83, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3c, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd3, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0xc, + 0xff, 0xff, 0xff, 0x72, 0x0, 0x26, 0xbf, 0xff, + 0xff, 0xfa, 0x0, 0x3, 0xff, 0xff, 0xfe, 0x20, + 0x0, 0x0, 0x0, 0x2a, 0xff, 0xf7, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xd4, 0x0, 0x0, 0xc, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xfd, 0x62, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xed, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xfd, 0x74, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0x60, 0x0, 0x6f, 0xff, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1c, + 0xff, 0x90, 0x1, 0xff, 0xff, 0xff, 0xc1, 0x0, + 0x0, 0x0, 0x0, 0x5e, 0xff, 0xff, 0xb0, 0x9, + 0xff, 0xff, 0xff, 0xe6, 0x0, 0x0, 0x15, 0xcf, + 0xff, 0xff, 0xff, 0xa0, 0x1e, 0xff, 0xff, 0xff, + 0xff, 0xdc, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xd1, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x3e, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x50, + 0x0, 0x0, 0x0, 0x19, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x69, 0xde, 0xff, 0xed, 0xb7, 0x30, 0x0, + 0x0, 0x0, + + /* U+03B6 "ζ" */ + 0x0, 0x0, 0x5, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, + 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0x60, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xfa, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3d, 0xff, 0xff, 0xe5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xd6, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xec, 0xa9, 0x75, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x40, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xb1, 0x0, 0x0, + 0x0, 0x2, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x7d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x57, + 0x88, 0x99, 0xab, 0xef, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1d, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x8e, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xfe, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xc6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x47, 0x64, + 0x10, 0x0, 0x0, 0x0, 0x0, + + /* U+03B7 "η" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x33, + 0x33, 0x20, 0x0, 0x0, 0x27, 0xbe, 0xff, 0xfe, + 0xc8, 0x30, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xfb, + 0x0, 0x2, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xc4, 0x0, 0x0, 0x8, 0xff, 0xff, 0xb0, 0x6, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x8f, 0xff, 0xfb, 0x8, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x8, 0xff, 0xff, 0xb7, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x8f, + 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x62, 0x10, 0x14, + 0x8f, 0xff, 0xff, 0xff, 0xf1, 0x8, 0xff, 0xff, + 0xff, 0xff, 0xe4, 0x0, 0x0, 0x0, 0x0, 0x1c, + 0xff, 0xff, 0xff, 0x70, 0x8f, 0xff, 0xff, 0xff, + 0xc1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0xfb, 0x8, 0xff, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xe0, 0x8f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x8, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xf2, 0x8f, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0x38, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xf4, 0x8f, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x48, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, + 0x8f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x48, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf4, 0x8f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x48, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf4, 0x8f, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0x48, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x8f, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0x48, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf4, 0x8f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x48, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf4, 0x8f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x48, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x8f, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x48, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf4, 0x8f, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x48, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, + 0x8f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x48, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf4, 0x8f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x48, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x40, + + /* U+03B8 "θ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x48, 0xab, + 0xcb, 0x97, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x81, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xe8, 0x30, + 0x2, 0x5b, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfb, 0x10, 0x0, + 0x0, 0x0, 0x4e, 0xff, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x20, + 0x0, 0xbf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x70, + 0x0, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xb0, + 0x2, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xe0, + 0x5, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf1, + 0x8, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf3, + 0xa, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf5, + 0xb, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf7, + 0xd, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf9, + 0xe, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xfa, + 0xf, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xfb, + 0xf, 0xff, 0xff, 0xfa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xab, 0xff, 0xff, 0xfb, + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0xf, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xfb, + 0xe, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xfa, + 0xd, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf9, + 0xc, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf8, + 0xa, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf6, + 0x8, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf4, + 0x6, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf2, + 0x3, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf0, + 0x0, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xc0, + 0x0, 0xcf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x80, + 0x0, 0x8f, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x40, + 0x0, 0x3f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x1b, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xc4, 0x0, + 0x0, 0x16, 0xef, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xff, 0xfd, + 0xcd, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xdf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x8b, 0xef, + 0xff, 0xdb, 0x72, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03B9 "ι" */ + 0x23, 0x33, 0x33, 0x9, 0xff, 0xff, 0xf3, 0x9f, + 0xff, 0xff, 0x39, 0xff, 0xff, 0xf3, 0x9f, 0xff, + 0xff, 0x39, 0xff, 0xff, 0xf3, 0x9f, 0xff, 0xff, + 0x39, 0xff, 0xff, 0xf3, 0x9f, 0xff, 0xff, 0x39, + 0xff, 0xff, 0xf3, 0x9f, 0xff, 0xff, 0x39, 0xff, + 0xff, 0xf3, 0x9f, 0xff, 0xff, 0x39, 0xff, 0xff, + 0xf3, 0x9f, 0xff, 0xff, 0x39, 0xff, 0xff, 0xf3, + 0x9f, 0xff, 0xff, 0x39, 0xff, 0xff, 0xf3, 0x9f, + 0xff, 0xff, 0x39, 0xff, 0xff, 0xf3, 0x9f, 0xff, + 0xff, 0x39, 0xff, 0xff, 0xf3, 0x9f, 0xff, 0xff, + 0x39, 0xff, 0xff, 0xf3, 0x9f, 0xff, 0xff, 0x39, + 0xff, 0xff, 0xf3, 0x9f, 0xff, 0xff, 0x39, 0xff, + 0xff, 0xf3, 0x9f, 0xff, 0xff, 0x39, 0xff, 0xff, + 0xf3, 0x9f, 0xff, 0xff, 0x39, 0xff, 0xff, 0xf3, + 0x9f, 0xff, 0xff, 0x39, 0xff, 0xff, 0xf3, 0x9f, + 0xff, 0xff, 0x30, + + /* U+03BA "κ" */ + 0x23, 0x33, 0x33, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x33, 0x33, 0x33, 0x31, 0xb, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xfc, 0x10, 0xbf, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xfb, 0x0, 0xb, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x1, 0xcf, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x1, + 0xcf, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x1, 0xdf, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x10, + 0x0, 0x2, 0xdf, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xf1, 0x0, 0x2, + 0xef, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0x10, 0x2, 0xef, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xf1, 0x2, 0xef, 0xff, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0x13, 0xef, 0xff, 0xff, 0xe2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf5, + 0xff, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0x84, + 0xff, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x70, 0x7, 0xff, + 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xf1, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x10, 0x0, 0xc, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xf4, + 0x0, 0xb, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xe2, 0x0, + 0xbf, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xd0, 0xb, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xff, 0xb0, 0xbf, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xff, 0x80, + + /* U+03BB "λ" */ + 0x0, 0x0, 0x0, 0x0, 0x48, 0x88, 0x88, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf3, 0xff, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xfa, 0xc, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0x40, 0x6f, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xe0, 0x0, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf8, 0x0, 0xa, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xff, 0x30, 0x0, 0x4f, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x10, 0x0, 0x8, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xf7, 0x0, 0x0, 0xef, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xd0, 0x0, 0x4f, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0x30, 0xa, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf9, 0x1, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xe0, + + /* U+03BC "μ" */ + 0x25, 0x55, 0x55, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x25, 0x55, 0x55, 0x7, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf2, 0x7f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x27, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf2, 0x7f, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0x27, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf2, 0x7f, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0x27, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf2, 0x7f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x27, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf2, 0x7f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x27, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf2, 0x7f, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x27, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf2, 0x7f, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x27, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf2, + 0x7f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x27, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xf2, 0x7f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0x27, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xf2, 0x7f, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0x27, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf2, 0x7f, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0x27, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xf2, 0x7f, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0x27, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xf2, 0x7f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0x27, + 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xf2, 0x7f, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0xff, 0x27, 0xff, 0xff, 0xff, + 0xff, 0xd3, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xff, 0xf2, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xfb, 0x75, 0x46, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x27, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xf2, + 0x7f, 0xff, 0xff, 0x6f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x2f, 0xff, 0xff, 0x27, 0xff, + 0xff, 0xf4, 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x20, 0xff, 0xff, 0xf2, 0x7f, 0xff, 0xff, + 0x40, 0x2b, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x10, + 0xe, 0xee, 0xee, 0x27, 0xff, 0xff, 0xf4, 0x0, + 0x3, 0x9d, 0xff, 0xec, 0x83, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03BD "ν" */ + 0xe, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0x10, 0x9f, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xa0, 0x3, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xf4, 0x0, 0xd, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0x80, 0x0, 0x1, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0xef, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0x50, 0x0, 0x4f, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xfb, 0x0, 0x9, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf1, 0x0, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x60, 0x5f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xfb, 0xa, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xf1, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0x9f, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+03BE "ξ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x15, 0x8b, 0xde, + 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1a, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xdd, 0xcc, + 0xcc, 0xb0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xd7, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xb6, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1d, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0xdc, 0xcc, 0xcc, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x1c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x26, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2c, + 0xff, 0xff, 0xff, 0xfc, 0x85, 0x31, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, + 0x82, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xfb, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xfb, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0xff, 0xe9, 0x63, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x94, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x8e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0x9c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x14, + 0x7b, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xbf, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xef, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x17, 0x9c, 0xff, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0xd3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xfe, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7e, 0xdb, + 0x84, 0x0, 0x0, 0x0, 0x0, + + /* U+03BF "ο" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x59, 0xbc, + 0xcb, 0xa8, 0x51, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6c, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, + 0xfc, 0x73, 0x10, 0x13, 0x8e, 0xff, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xe5, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x4f, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xfe, 0x0, 0x9, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xf4, 0x0, 0xef, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0x90, 0x2f, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xfd, 0x5, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf0, 0x7f, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x29, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf4, + 0xaf, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0x5a, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xf6, 0xaf, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0x5a, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xf5, 0x9f, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x47, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xf2, 0x5f, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x2, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xd0, 0xe, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xf9, 0x0, 0xaf, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0x50, 0x5, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xe0, 0x0, 0xe, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2e, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xfc, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x4e, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x2, 0xef, 0xff, 0xff, 0xff, 0x93, 0x0, 0x0, + 0x5, 0xbf, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x3, 0xef, 0xff, 0xff, 0xff, 0xff, 0xdc, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2a, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe8, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x59, + 0xce, 0xff, 0xfe, 0xb8, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+03C0 "π" */ + 0x6b, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, + 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, + 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xb1, 0x8f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf2, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf2, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0x88, 0x88, 0x82, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0x88, 0x88, 0x82, 0x0, 0x0, + 0x0, 0x0, + + /* U+03C1 "ρ" */ + 0x0, 0x0, 0x0, 0x0, 0x1, 0x6a, 0xce, 0xff, + 0xfd, 0xb7, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xed, + 0xef, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xfb, 0x40, 0x0, + 0x1, 0x5c, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xfe, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xef, 0xff, 0xff, 0xa0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, 0x0, + 0x7, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xfa, 0x0, + 0xc, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x10, + 0xf, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0x50, + 0x3f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xa0, + 0x6f, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xd0, + 0x8f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf0, + 0xaf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf1, + 0xbf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf2, + 0xbf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf3, + 0xcf, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf3, + 0xcf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf2, + 0xcf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf1, + 0xcf, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf0, + 0xcf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xc0, + 0xcf, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x90, + 0xcf, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x50, + 0xcf, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x0, + 0xcf, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xfa, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf2, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xfe, 0x10, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x73, 0x10, + 0x13, 0x8e, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x3e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x2, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x0, 0x4, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x60, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x0, 0x0, 0x1, 0x59, 0xab, + 0xcb, 0x96, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03C2 "ς" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x58, 0xab, 0xcc, 0xcb, 0x97, 0x41, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x39, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4c, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x1a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x3, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0xfc, 0x84, 0x21, 0x0, 0x13, 0x58, + 0xce, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0xfa, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, 0xfd, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xc1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xfd, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0xff, 0xe8, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x94, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1b, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xa2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3a, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0x7b, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x9e, 0xff, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xaf, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x19, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0x97, 0x66, 0x7b, 0xff, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6b, 0xde, 0xff, + 0xed, 0xa6, 0x10, 0x0, 0x0, 0x0, 0x0, + + /* U+03C3 "σ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x69, 0xbc, + 0xcb, 0x97, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x6, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x1, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x2d, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x1, 0xdf, 0xff, 0xff, 0xff, 0xb6, 0x21, 0x2, + 0x48, 0xef, 0xff, 0xff, 0xff, 0xbb, 0xbb, 0xbb, + 0xbb, 0xb3, 0x0, 0xb, 0xff, 0xff, 0xff, 0xd4, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0x10, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0x30, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0x30, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0x30, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0x30, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, + 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xff, 0x91, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xef, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xfe, + 0x72, 0x0, 0x0, 0x5, 0xbf, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0xde, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1b, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4b, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x16, 0xac, + 0xef, 0xff, 0xdb, 0x73, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+03C4 "τ" */ + 0x5b, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, + 0xbb, 0xbb, 0xbb, 0xb6, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0x88, 0x88, 0x82, + 0x0, 0x0, 0x0, 0x0, + + /* U+03C5 "υ" */ + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xfb, 0x9f, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xfa, 0x8f, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xf9, 0x6f, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf8, + 0x4f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xf5, 0x1f, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xf1, 0xd, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xd0, 0x8, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0x70, + 0x1, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x3e, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xff, 0xb3, 0x0, 0x0, 0x29, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0xde, 0xff, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xa2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x16, 0xad, 0xef, 0xfe, 0xc9, 0x51, 0x0, 0x0, + 0x0, 0x0, + + /* U+03C6 "φ" */ + 0x0, 0x0, 0x0, 0x0, 0x1, 0x6b, 0xee, 0x0, + 0x0, 0x0, 0x5a, 0xef, 0xfe, 0xda, 0x72, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xb0, 0x0, 0x2, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3e, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xff, 0xf1, 0x0, 0xd, 0xff, + 0xff, 0xff, 0xfd, 0xef, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xb3, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xb1, 0x0, 0x3b, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xfe, 0x40, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xfe, 0x30, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0xef, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xd0, 0x0, + 0x6f, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0x40, 0xb, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xf9, 0x0, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xe0, 0x3f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0x16, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xf4, 0x8f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0x69, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf7, + 0xaf, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0x8a, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf7, 0x9f, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x68, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xf3, 0x6f, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0x13, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xc0, 0xf, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf8, + 0x0, 0xbf, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0x20, 0x6, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xc0, 0x0, + 0xe, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x1e, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0x80, 0x0, 0x3e, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xfe, 0x60, 0x4, 0xff, 0xff, + 0xf8, 0x1, 0x9f, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, + 0xea, 0x8f, 0xff, 0xff, 0xcc, 0xff, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4b, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x92, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x69, 0xbd, 0xff, 0xff, 0xfd, 0x84, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03C7 "χ" */ + 0x1, 0x55, 0x55, 0x54, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0x55, 0x55, + 0x51, 0x0, 0x1f, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0x60, 0x0, 0x0, 0xef, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xb0, 0x0, 0x1, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x30, 0x0, + 0x9f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xfb, + 0x0, 0x2f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xf3, 0xa, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xb2, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xdf, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xfb, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xfa, 0x1f, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0x20, 0x9f, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x90, 0x1, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf1, + 0x0, 0x8, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x80, 0x0, 0x0, 0x1, 0xef, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x1f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xfa, 0x0, 0xa, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf3, 0x2, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xc0, + + /* U+03C8 "ψ" */ + 0x5, 0x55, 0x55, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x55, 0x55, 0x52, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x35, 0x55, 0x55, 0x1, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xf1, 0x1f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x11, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xf1, 0x1f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x11, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xf1, 0x1f, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x11, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xf1, 0x1f, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0x11, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xf1, 0x1f, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0x11, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xf1, 0x1f, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x11, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf1, 0x1f, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0x11, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf1, + 0x1f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0x10, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xf1, 0xf, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x10, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xf0, 0xf, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x0, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xf0, 0xe, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfd, 0x0, + 0xcf, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xc0, 0xa, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf9, + 0x0, 0x7f, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0x60, 0x3, 0xff, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xf2, 0x0, 0xd, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xfd, + 0x40, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x4d, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xff, 0xff, 0xd7, 0x42, 0x6, + 0xff, 0xff, 0xf6, 0x1, 0x47, 0xdf, 0xff, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x18, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe8, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x26, 0x8a, 0xcd, 0xef, 0xff, + 0xff, 0xec, 0xcb, 0x86, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03C9 "ω" */ + 0x0, 0x0, 0x6, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xa0, 0x0, 0x7, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x18, 0x88, + 0x88, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xf5, 0x0, 0x1f, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0x90, 0x5, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xfd, 0x0, 0x9f, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf1, 0xb, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0x40, 0xef, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xf6, 0xf, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0x81, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xfa, + 0x2f, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xb3, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xfb, 0x2f, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xb1, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xfa, 0xf, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0x90, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xf8, 0xc, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0x50, 0x9f, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xf3, 0x6, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0x0, 0x1f, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xb0, 0x0, 0xcf, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xf6, 0x0, 0x6, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xcf, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfd, 0x10, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf3, 0xaf, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfd, 0x30, + 0x0, 0x3, 0xdf, 0xff, 0xfa, 0x2, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xc9, + 0x9c, 0xff, 0xff, 0xfe, 0x10, 0x7, 0xff, 0xff, + 0xff, 0xa9, 0xae, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x40, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7e, 0xff, 0xff, 0xff, 0xff, + 0xfb, 0x20, 0x0, 0x0, 0x0, 0x6, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xb2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xad, 0xff, 0xec, 0x93, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6a, 0xdf, + 0xfe, 0xc8, 0x20, 0x0, 0x0, 0x0, 0x0, + + /* U+03CA "ϊ" */ + 0x79, 0x99, 0x99, 0x20, 0x0, 0x0, 0x79, 0x99, + 0x99, 0x3c, 0xff, 0xff, 0xf4, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xf5, 0xcf, 0xff, 0xff, 0x40, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0x5c, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf5, 0xcf, 0xff, + 0xff, 0x40, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x5c, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xf5, 0xcf, 0xff, 0xff, 0x40, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x33, + 0x33, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + + /* U+03CB "ϋ" */ + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf1, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf1, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x9, 0x99, + 0x99, 0x90, 0x0, 0x0, 0x9, 0x99, 0x99, 0x91, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xfb, 0x9f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xfa, 0x8f, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf9, + 0x6f, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xf8, 0x4f, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf5, 0x1f, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xf1, 0xd, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xd0, + 0x8, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xef, 0xff, 0xff, 0x70, 0x1, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x3e, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xff, 0xb3, 0x0, 0x0, 0x29, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0xde, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2a, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x16, 0xad, + 0xef, 0xfe, 0xc9, 0x51, 0x0, 0x0, 0x0, 0x0, + + /* U+03CC "ό" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x59, 0xbc, 0xcb, + 0xa8, 0x51, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1c, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xfc, + 0x73, 0x10, 0x13, 0x8e, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xe5, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x4f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xfe, 0x0, 0x9, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf4, 0x0, 0xef, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0x90, 0x2f, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xfd, 0x5, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf0, 0x7f, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x29, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf4, 0xaf, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0x5a, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf6, + 0xaf, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0x5a, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xf5, 0x9f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0x47, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xf2, 0x5f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x2, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xd0, 0xe, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xf9, 0x0, 0xaf, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0x50, 0x5, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xe0, 0x0, 0xe, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2e, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xfc, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x4e, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x2, + 0xef, 0xff, 0xff, 0xff, 0x93, 0x0, 0x0, 0x5, + 0xbf, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x3, 0xef, 0xff, 0xff, 0xff, 0xff, 0xdc, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2a, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe8, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x59, 0xce, + 0xff, 0xfe, 0xb8, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+03CD "ύ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7b, 0xbb, 0xbb, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbb, 0xbb, 0xb8, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xfc, 0x9f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xfb, 0x8f, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xf9, 0x7f, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xf8, 0x5f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf5, + 0x1f, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf1, 0xe, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xe0, 0x8, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, + 0xff, 0x70, 0x1, 0xff, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x3e, 0xff, 0xff, 0xff, 0x10, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0xa3, 0x0, 0x0, + 0x29, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0xde, 0xff, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2b, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xa2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x16, 0xad, 0xef, 0xfe, 0xca, 0x51, + 0x0, 0x0, 0x0, 0x0, + + /* U+03CE "ώ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3b, 0xbb, 0xbb, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xbb, 0xbb, 0x90, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xc0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0x20, 0x0, 0x1, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xe0, 0x0, 0xb, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x22, + 0x22, 0x21, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x40, 0x0, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf8, 0x0, 0x4f, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xc0, 0x8, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x0, 0xbf, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xf3, 0xe, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0x60, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xf8, 0x1f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xa2, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xfb, + 0x3f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xb2, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xfb, 0x1f, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xa0, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xf9, 0xf, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0x80, 0xcf, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xf5, 0x9, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0x20, 0x6f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf0, 0x2, 0xff, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xfb, 0x0, 0xc, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0x50, 0x0, 0x6f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xfc, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x3a, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xd3, + 0x0, 0x0, 0x3d, 0xff, 0xff, 0xb0, 0x2f, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xfc, + 0x99, 0xcf, 0xff, 0xff, 0xf1, 0x0, 0x8f, 0xff, + 0xff, 0xfa, 0x9a, 0xef, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x1b, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xc2, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6a, 0xdf, 0xfe, 0xc9, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xad, + 0xff, 0xec, 0x82, 0x0, 0x0, 0x0, 0x0, + + /* U+03F4 "ϴ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x23, 0x33, 0x32, 0x0, 0x0, 0xe, 0xff, 0xff, + 0x60, 0x23, 0x33, 0x32, 0xbf, 0xff, 0xfd, 0x0, + 0x0, 0x7f, 0xff, 0xfa, 0x0, 0xdf, 0xff, 0xfb, + 0xbf, 0xff, 0xfd, 0x0, 0x0, 0xef, 0xff, 0xe1, + 0x0, 0xdf, 0xff, 0xfb, 0xbf, 0xff, 0xfd, 0x0, + 0x6, 0xff, 0xff, 0x30, 0x0, 0xdf, 0xff, 0xfb, + 0xbf, 0xff, 0xfd, 0x0, 0xd, 0xff, 0xf8, 0x0, + 0x0, 0xdf, 0xff, 0xfb, 0xbf, 0xff, 0xfd, 0x0, + 0x5f, 0xff, 0xc0, 0x0, 0x0, 0xdf, 0xff, 0xfb, + 0xbf, 0xff, 0xfd, 0x0, 0xcf, 0xff, 0x20, 0x0, + 0x0, 0xdf, 0xff, 0xfb +}; + + +/*--------------------- + * GLYPH DESCRIPTION + *--------------------*/ + +static const lv_font_fmt_txt_glyph_dsc_t glyph_dsc[] = { + {.bitmap_index = 0, .adv_w = 0, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0} /* id = 0 reserved */, + {.bitmap_index = 0, .adv_w = 293, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 0, .adv_w = 294, .box_w = 8, .box_h = 47, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 188, .adv_w = 374, .box_w = 18, .box_h = 17, .ofs_x = 3, .ofs_y = 31}, + {.bitmap_index = 341, .adv_w = 587, .box_w = 36, .box_h = 49, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 1223, .adv_w = 587, .box_w = 32, .box_h = 59, .ofs_x = 2, .ofs_y = -7}, + {.bitmap_index = 2167, .adv_w = 939, .box_w = 52, .box_h = 50, .ofs_x = 3, .ofs_y = -2}, + {.bitmap_index = 3467, .adv_w = 705, .box_w = 41, .box_h = 50, .ofs_x = 2, .ofs_y = -2}, + {.bitmap_index = 4492, .adv_w = 200, .box_w = 7, .box_h = 17, .ofs_x = 3, .ofs_y = 31}, + {.bitmap_index = 4552, .adv_w = 352, .box_w = 16, .box_h = 62, .ofs_x = 4, .ofs_y = -14}, + {.bitmap_index = 5048, .adv_w = 352, .box_w = 16, .box_h = 62, .ofs_x = 2, .ofs_y = -14}, + {.bitmap_index = 5544, .adv_w = 410, .box_w = 22, .box_h = 21, .ofs_x = 2, .ofs_y = 27}, + {.bitmap_index = 5775, .adv_w = 617, .box_w = 32, .box_h = 32, .ofs_x = 3, .ofs_y = 8}, + {.bitmap_index = 6287, .adv_w = 294, .box_w = 8, .box_h = 17, .ofs_x = 5, .ofs_y = -10}, + {.bitmap_index = 6355, .adv_w = 352, .box_w = 18, .box_h = 6, .ofs_x = 2, .ofs_y = 14}, + {.bitmap_index = 6409, .adv_w = 294, .box_w = 8, .box_h = 7, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 6437, .adv_w = 293, .box_w = 19, .box_h = 49, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 6903, .adv_w = 587, .box_w = 32, .box_h = 48, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 7671, .adv_w = 587, .box_w = 18, .box_h = 48, .ofs_x = 7, .ofs_y = 0}, + {.bitmap_index = 8103, .adv_w = 587, .box_w = 32, .box_h = 48, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 8871, .adv_w = 587, .box_w = 32, .box_h = 48, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 9639, .adv_w = 587, .box_w = 34, .box_h = 48, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 10455, .adv_w = 587, .box_w = 33, .box_h = 48, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 11247, .adv_w = 587, .box_w = 32, .box_h = 48, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 12015, .adv_w = 587, .box_w = 31, .box_h = 47, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 12744, .adv_w = 587, .box_w = 32, .box_h = 48, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 13512, .adv_w = 587, .box_w = 32, .box_h = 48, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 14280, .adv_w = 294, .box_w = 8, .box_h = 34, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 14416, .adv_w = 294, .box_w = 8, .box_h = 44, .ofs_x = 5, .ofs_y = -10}, + {.bitmap_index = 14592, .adv_w = 617, .box_w = 32, .box_h = 33, .ofs_x = 3, .ofs_y = 7}, + {.bitmap_index = 15120, .adv_w = 617, .box_w = 32, .box_h = 20, .ofs_x = 3, .ofs_y = 13}, + {.bitmap_index = 15440, .adv_w = 617, .box_w = 32, .box_h = 33, .ofs_x = 3, .ofs_y = 7}, + {.bitmap_index = 15968, .adv_w = 587, .box_w = 31, .box_h = 48, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 16712, .adv_w = 1072, .box_w = 62, .box_h = 62, .ofs_x = 3, .ofs_y = -14}, + {.bitmap_index = 18634, .adv_w = 705, .box_w = 46, .box_h = 48, .ofs_x = -1, .ofs_y = -1}, + {.bitmap_index = 19738, .adv_w = 705, .box_w = 37, .box_h = 47, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 20608, .adv_w = 763, .box_w = 43, .box_h = 49, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 21662, .adv_w = 763, .box_w = 40, .box_h = 47, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 22602, .adv_w = 705, .box_w = 36, .box_h = 47, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 23448, .adv_w = 647, .box_w = 33, .box_h = 48, .ofs_x = 5, .ofs_y = -1}, + {.bitmap_index = 24240, .adv_w = 821, .box_w = 45, .box_h = 49, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 25343, .adv_w = 763, .box_w = 38, .box_h = 48, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 26255, .adv_w = 294, .box_w = 7, .box_h = 48, .ofs_x = 6, .ofs_y = 0}, + {.bitmap_index = 26423, .adv_w = 528, .box_w = 27, .box_h = 48, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 27071, .adv_w = 705, .box_w = 40, .box_h = 48, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 28031, .adv_w = 587, .box_w = 31, .box_h = 48, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 28775, .adv_w = 880, .box_w = 47, .box_h = 48, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 29903, .adv_w = 763, .box_w = 38, .box_h = 48, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 30815, .adv_w = 821, .box_w = 46, .box_h = 49, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 31942, .adv_w = 705, .box_w = 37, .box_h = 47, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 32812, .adv_w = 821, .box_w = 47, .box_h = 52, .ofs_x = 3, .ofs_y = -4}, + {.bitmap_index = 34034, .adv_w = 763, .box_w = 42, .box_h = 48, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 35042, .adv_w = 705, .box_w = 39, .box_h = 49, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 35998, .adv_w = 647, .box_w = 38, .box_h = 48, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 36910, .adv_w = 763, .box_w = 38, .box_h = 48, .ofs_x = 5, .ofs_y = -1}, + {.bitmap_index = 37822, .adv_w = 705, .box_w = 44, .box_h = 48, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 38878, .adv_w = 997, .box_w = 62, .box_h = 48, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 40366, .adv_w = 705, .box_w = 44, .box_h = 48, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 41422, .adv_w = 705, .box_w = 44, .box_h = 48, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 42478, .adv_w = 647, .box_w = 38, .box_h = 47, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 43371, .adv_w = 294, .box_w = 14, .box_h = 60, .ofs_x = 4, .ofs_y = -13}, + {.bitmap_index = 43791, .adv_w = 293, .box_w = 19, .box_h = 49, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 44257, .adv_w = 294, .box_w = 13, .box_h = 60, .ofs_x = 1, .ofs_y = -13}, + {.bitmap_index = 44647, .adv_w = 496, .box_w = 29, .box_h = 26, .ofs_x = 1, .ofs_y = 22}, + {.bitmap_index = 45024, .adv_w = 587, .box_w = 39, .box_h = 5, .ofs_x = -1, .ofs_y = -13}, + {.bitmap_index = 45122, .adv_w = 352, .box_w = 13, .box_h = 10, .ofs_x = 2, .ofs_y = 38}, + {.bitmap_index = 45187, .adv_w = 587, .box_w = 33, .box_h = 36, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 45781, .adv_w = 587, .box_w = 31, .box_h = 48, .ofs_x = 4, .ofs_y = -1}, + {.bitmap_index = 46525, .adv_w = 528, .box_w = 31, .box_h = 36, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 47083, .adv_w = 587, .box_w = 31, .box_h = 48, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 47827, .adv_w = 587, .box_w = 33, .box_h = 36, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 48421, .adv_w = 294, .box_w = 21, .box_h = 49, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 48936, .adv_w = 587, .box_w = 31, .box_h = 49, .ofs_x = 2, .ofs_y = -14}, + {.bitmap_index = 49696, .adv_w = 587, .box_w = 29, .box_h = 48, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 50392, .adv_w = 235, .box_w = 7, .box_h = 47, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 50557, .adv_w = 235, .box_w = 14, .box_h = 61, .ofs_x = -3, .ofs_y = -14}, + {.bitmap_index = 50984, .adv_w = 528, .box_w = 29, .box_h = 48, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 51680, .adv_w = 235, .box_w = 7, .box_h = 48, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 51848, .adv_w = 880, .box_w = 47, .box_h = 35, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 52671, .adv_w = 587, .box_w = 29, .box_h = 35, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 53179, .adv_w = 587, .box_w = 33, .box_h = 36, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 53773, .adv_w = 587, .box_w = 31, .box_h = 48, .ofs_x = 4, .ofs_y = -13}, + {.bitmap_index = 54517, .adv_w = 587, .box_w = 31, .box_h = 48, .ofs_x = 2, .ofs_y = -13}, + {.bitmap_index = 55261, .adv_w = 352, .box_w = 19, .box_h = 35, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 55594, .adv_w = 528, .box_w = 29, .box_h = 36, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 56116, .adv_w = 294, .box_w = 17, .box_h = 47, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 56516, .adv_w = 587, .box_w = 29, .box_h = 35, .ofs_x = 4, .ofs_y = -1}, + {.bitmap_index = 57024, .adv_w = 528, .box_w = 33, .box_h = 34, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 57585, .adv_w = 763, .box_w = 48, .box_h = 34, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 58401, .adv_w = 528, .box_w = 33, .box_h = 35, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 58979, .adv_w = 528, .box_w = 32, .box_h = 48, .ofs_x = 1, .ofs_y = -14}, + {.bitmap_index = 59747, .adv_w = 528, .box_w = 31, .box_h = 34, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 60274, .adv_w = 352, .box_w = 20, .box_h = 62, .ofs_x = 1, .ofs_y = -14}, + {.bitmap_index = 60894, .adv_w = 274, .box_w = 6, .box_h = 62, .ofs_x = 6, .ofs_y = -14}, + {.bitmap_index = 61080, .adv_w = 352, .box_w = 20, .box_h = 62, .ofs_x = 1, .ofs_y = -14}, + {.bitmap_index = 61700, .adv_w = 617, .box_w = 34, .box_h = 12, .ofs_x = 2, .ofs_y = 17}, + {.bitmap_index = 61904, .adv_w = 293, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 61904, .adv_w = 587, .box_w = 34, .box_h = 50, .ofs_x = 1, .ofs_y = -2}, + {.bitmap_index = 62754, .adv_w = 587, .box_w = 33, .box_h = 33, .ofs_x = 2, .ofs_y = 7}, + {.bitmap_index = 63299, .adv_w = 587, .box_w = 37, .box_h = 48, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 64187, .adv_w = 275, .box_w = 6, .box_h = 62, .ofs_x = 6, .ofs_y = -14}, + {.bitmap_index = 64373, .adv_w = 587, .box_w = 32, .box_h = 62, .ofs_x = 2, .ofs_y = -14}, + {.bitmap_index = 65365, .adv_w = 352, .box_w = 20, .box_h = 7, .ofs_x = 1, .ofs_y = 41}, + {.bitmap_index = 65435, .adv_w = 778, .box_w = 49, .box_h = 49, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 66636, .adv_w = 396, .box_w = 23, .box_h = 24, .ofs_x = 1, .ofs_y = 24}, + {.bitmap_index = 66912, .adv_w = 587, .box_w = 29, .box_h = 30, .ofs_x = 4, .ofs_y = 2}, + {.bitmap_index = 67347, .adv_w = 617, .box_w = 32, .box_h = 20, .ofs_x = 3, .ofs_y = 14}, + {.bitmap_index = 67667, .adv_w = 352, .box_w = 18, .box_h = 6, .ofs_x = 2, .ofs_y = 14}, + {.bitmap_index = 67721, .adv_w = 778, .box_w = 49, .box_h = 49, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 68922, .adv_w = 422, .box_w = 19, .box_h = 18, .ofs_x = 4, .ofs_y = 30}, + {.bitmap_index = 69093, .adv_w = 617, .box_w = 32, .box_h = 40, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 69733, .adv_w = 352, .box_w = 21, .box_h = 24, .ofs_x = 0, .ofs_y = 24}, + {.bitmap_index = 69985, .adv_w = 352, .box_w = 20, .box_h = 25, .ofs_x = 1, .ofs_y = 23}, + {.bitmap_index = 70235, .adv_w = 587, .box_w = 29, .box_h = 48, .ofs_x = 4, .ofs_y = -13}, + {.bitmap_index = 70931, .adv_w = 567, .box_w = 37, .box_h = 61, .ofs_x = -1, .ofs_y = -13}, + {.bitmap_index = 72060, .adv_w = 296, .box_w = 8, .box_h = 7, .ofs_x = 5, .ofs_y = 20}, + {.bitmap_index = 72088, .adv_w = 587, .box_w = 29, .box_h = 30, .ofs_x = 4, .ofs_y = 2}, + {.bitmap_index = 72523, .adv_w = 881, .box_w = 51, .box_h = 50, .ofs_x = 3, .ofs_y = -2}, + {.bitmap_index = 73798, .adv_w = 352, .box_w = 13, .box_h = 10, .ofs_x = 7, .ofs_y = 40}, + {.bitmap_index = 73863, .adv_w = 705, .box_w = 46, .box_h = 48, .ofs_x = -1, .ofs_y = -1}, + {.bitmap_index = 74967, .adv_w = 828, .box_w = 52, .box_h = 48, .ofs_x = -3, .ofs_y = 0}, + {.bitmap_index = 76215, .adv_w = 885, .box_w = 52, .box_h = 48, .ofs_x = -3, .ofs_y = 0}, + {.bitmap_index = 77463, .adv_w = 405, .box_w = 21, .box_h = 48, .ofs_x = -3, .ofs_y = 0}, + {.bitmap_index = 77967, .adv_w = 818, .box_w = 52, .box_h = 49, .ofs_x = -3, .ofs_y = -1}, + {.bitmap_index = 79241, .adv_w = 903, .box_w = 59, .box_h = 48, .ofs_x = -3, .ofs_y = 0}, + {.bitmap_index = 80657, .adv_w = 795, .box_w = 50, .box_h = 48, .ofs_x = -3, .ofs_y = 0}, + {.bitmap_index = 81857, .adv_w = 235, .box_w = 25, .box_h = 49, .ofs_x = -5, .ofs_y = 0}, + {.bitmap_index = 82470, .adv_w = 705, .box_w = 46, .box_h = 48, .ofs_x = -1, .ofs_y = -1}, + {.bitmap_index = 83574, .adv_w = 705, .box_w = 37, .box_h = 47, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 84444, .adv_w = 582, .box_w = 30, .box_h = 48, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 85164, .adv_w = 705, .box_w = 46, .box_h = 48, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 86268, .adv_w = 705, .box_w = 36, .box_h = 47, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 87114, .adv_w = 647, .box_w = 38, .box_h = 47, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 88007, .adv_w = 763, .box_w = 38, .box_h = 48, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 88919, .adv_w = 821, .box_w = 46, .box_h = 49, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 90046, .adv_w = 294, .box_w = 7, .box_h = 48, .ofs_x = 6, .ofs_y = 0}, + {.bitmap_index = 90214, .adv_w = 705, .box_w = 40, .box_h = 48, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 91174, .adv_w = 705, .box_w = 44, .box_h = 48, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 92230, .adv_w = 880, .box_w = 47, .box_h = 48, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 93358, .adv_w = 763, .box_w = 38, .box_h = 48, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 94270, .adv_w = 686, .box_w = 37, .box_h = 47, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 95140, .adv_w = 821, .box_w = 46, .box_h = 49, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 96267, .adv_w = 763, .box_w = 38, .box_h = 48, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 97179, .adv_w = 705, .box_w = 37, .box_h = 47, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 98049, .adv_w = 653, .box_w = 35, .box_h = 47, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 98872, .adv_w = 647, .box_w = 38, .box_h = 48, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 99784, .adv_w = 705, .box_w = 44, .box_h = 48, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 100840, .adv_w = 843, .box_w = 48, .box_h = 51, .ofs_x = 2, .ofs_y = -2}, + {.bitmap_index = 102064, .adv_w = 705, .box_w = 44, .box_h = 48, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 103120, .adv_w = 882, .box_w = 48, .box_h = 48, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 104272, .adv_w = 789, .box_w = 44, .box_h = 48, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 105328, .adv_w = 294, .box_w = 20, .box_h = 57, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 105898, .adv_w = 705, .box_w = 44, .box_h = 57, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 107152, .adv_w = 611, .box_w = 34, .box_h = 50, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 108002, .adv_w = 471, .box_w = 25, .box_h = 50, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 108627, .adv_w = 587, .box_w = 29, .box_h = 62, .ofs_x = 4, .ofs_y = -13}, + {.bitmap_index = 109526, .adv_w = 235, .box_w = 13, .box_h = 49, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 109845, .adv_w = 578, .box_w = 28, .box_h = 50, .ofs_x = 4, .ofs_y = -1}, + {.bitmap_index = 110545, .adv_w = 611, .box_w = 34, .box_h = 36, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 111157, .adv_w = 607, .box_w = 31, .box_h = 61, .ofs_x = 4, .ofs_y = -13}, + {.bitmap_index = 112103, .adv_w = 528, .box_w = 33, .box_h = 48, .ofs_x = 0, .ofs_y = -13}, + {.bitmap_index = 112895, .adv_w = 588, .box_w = 33, .box_h = 48, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 113687, .adv_w = 471, .box_w = 25, .box_h = 36, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 114137, .adv_w = 466, .box_w = 27, .box_h = 62, .ofs_x = 2, .ofs_y = -14}, + {.bitmap_index = 114974, .adv_w = 587, .box_w = 29, .box_h = 49, .ofs_x = 4, .ofs_y = -13}, + {.bitmap_index = 115685, .adv_w = 587, .box_w = 32, .box_h = 49, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 116469, .adv_w = 235, .box_w = 7, .box_h = 35, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 116592, .adv_w = 526, .box_w = 29, .box_h = 35, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 117100, .adv_w = 528, .box_w = 33, .box_h = 48, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 117892, .adv_w = 587, .box_w = 29, .box_h = 48, .ofs_x = 4, .ofs_y = -13}, + {.bitmap_index = 118588, .adv_w = 528, .box_w = 33, .box_h = 34, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 119149, .adv_w = 473, .box_w = 27, .box_h = 62, .ofs_x = 2, .ofs_y = -14}, + {.bitmap_index = 119986, .adv_w = 587, .box_w = 33, .box_h = 36, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 120580, .adv_w = 729, .box_w = 44, .box_h = 35, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 121350, .adv_w = 601, .box_w = 32, .box_h = 48, .ofs_x = 4, .ofs_y = -13}, + {.bitmap_index = 122118, .adv_w = 509, .box_w = 30, .box_h = 49, .ofs_x = 2, .ofs_y = -14}, + {.bitmap_index = 122853, .adv_w = 652, .box_w = 38, .box_h = 36, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 123537, .adv_w = 417, .box_w = 24, .box_h = 35, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 123957, .adv_w = 578, .box_w = 28, .box_h = 35, .ofs_x = 4, .ofs_y = -1}, + {.bitmap_index = 124447, .adv_w = 685, .box_w = 39, .box_h = 48, .ofs_x = 2, .ofs_y = -13}, + {.bitmap_index = 125383, .adv_w = 554, .box_w = 35, .box_h = 48, .ofs_x = 0, .ofs_y = -13}, + {.bitmap_index = 126223, .adv_w = 753, .box_w = 41, .box_h = 48, .ofs_x = 3, .ofs_y = -13}, + {.bitmap_index = 127207, .adv_w = 824, .box_w = 47, .box_h = 35, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 128030, .adv_w = 235, .box_w = 19, .box_h = 48, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 128486, .adv_w = 578, .box_w = 28, .box_h = 48, .ofs_x = 4, .ofs_y = -1}, + {.bitmap_index = 129158, .adv_w = 587, .box_w = 33, .box_h = 50, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 129983, .adv_w = 578, .box_w = 28, .box_h = 50, .ofs_x = 4, .ofs_y = -1}, + {.bitmap_index = 130683, .adv_w = 824, .box_w = 47, .box_h = 50, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 131858, .adv_w = 352, .box_w = 24, .box_h = 9, .ofs_x = -1, .ofs_y = 40} +}; + +/*--------------------- + * CHARACTER MAPPING + *--------------------*/ + +static const uint8_t glyph_id_ofs_list_1[] = { + 0, 0, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 0, + 13, 14, 15, 16, 0, 17, 18, 19, + 0, 0, 0, 20, 0, 21 +}; + +static const uint8_t glyph_id_ofs_list_2[] = { + 0, 0, 1, 0, 2, 3, 4, 0, + 5 +}; + +/*Collect the unicode lists and glyph_id offsets*/ +static const lv_font_fmt_txt_cmap_t cmaps[] = +{ + { + .range_start = 32, .range_length = 95, .glyph_id_start = 1, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 160, .range_length = 30, .glyph_id_start = 96, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_1, .list_length = 30, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 900, .range_length = 9, .glyph_id_start = 118, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_2, .list_length = 9, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 910, .range_length = 20, .glyph_id_start = 124, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 931, .range_length = 44, .glyph_id_start = 144, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 1012, .range_length = 1, .glyph_id_start = 188, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + } +}; + + + +/*-------------------- + * ALL CUSTOM DATA + *--------------------*/ + +#if LVGL_VERSION_MAJOR == 8 +/*Store all the custom data of the font*/ +static lv_font_fmt_txt_glyph_cache_t cache; +#endif + +#if LVGL_VERSION_MAJOR >= 8 +static const lv_font_fmt_txt_dsc_t font_dsc = { +#else +static lv_font_fmt_txt_dsc_t font_dsc = { +#endif + .glyph_bitmap = glyph_bitmap, + .glyph_dsc = glyph_dsc, + .cmaps = cmaps, + .kern_dsc = NULL, + .kern_scale = 0, + .cmap_num = 6, + .bpp = 4, + .kern_classes = 0, + .bitmap_format = 0, +#if LVGL_VERSION_MAJOR == 8 + .cache = &cache +#endif + +}; + +extern const lv_font_t lv_font_montserrat_48; + + +/*----------------- + * PUBLIC FONT + *----------------*/ + +/*Initialize a public general font descriptor*/ +#if LVGL_VERSION_MAJOR >= 8 +const lv_font_t lv_font_arial_66 = { +#else +lv_font_t lv_font_arial_66 = { +#endif + .get_glyph_dsc = lv_font_get_glyph_dsc_fmt_txt, /*Function pointer to get glyph's data*/ + .get_glyph_bitmap = lv_font_get_bitmap_fmt_txt, /*Function pointer to get glyph's bitmap*/ + .line_height = 71, /*The maximum line height required by the font*/ + .base_line = 14, /*Baseline measured from the bottom of the line*/ +#if !(LVGL_VERSION_MAJOR == 6 && LVGL_VERSION_MINOR == 0) + .subpx = LV_FONT_SUBPX_NONE, +#endif +#if LV_VERSION_CHECK(7, 4, 0) || LVGL_VERSION_MAJOR >= 8 + .underline_position = -7, + .underline_thickness = 5, +#endif + //.static_bitmap = 0, + .dsc = &font_dsc, /*The custom font data. Will be accessed by `get_glyph_bitmap/dsc` */ +#if LV_VERSION_CHECK(8, 2, 0) || LVGL_VERSION_MAJOR >= 9 + .fallback = &lv_font_montserrat_48, +#endif + .user_data = NULL, +}; + + + +#endif /*#if LV_FONT_ARIAL_66*/ diff --git a/src/fonts/lv_font_arial_74.c b/src/fonts/lv_font_arial_74.c new file mode 100644 index 0000000000..54ba7b4fce --- /dev/null +++ b/src/fonts/lv_font_arial_74.c @@ -0,0 +1,21373 @@ +/******************************************************************************* + * Size: 74 px + * Bpp: 4 + * Opts: --bpp 4 --size 74 --no-compress --stride 1 --align 1 --font Arial Greek Regular.ttf --range 32-127,160-255,880-1023 --format lvgl -o lv_font_arial_74.c + ******************************************************************************/ + +#ifdef __has_include + #if __has_include("lvgl.h") + #ifndef LV_LVGL_H_INCLUDE_SIMPLE + #define LV_LVGL_H_INCLUDE_SIMPLE + #endif + #endif +#endif + +#ifdef LV_LVGL_H_INCLUDE_SIMPLE + #include "lvgl.h" +#else + #include "lvgl/lvgl.h" +#endif + + + +#ifndef LV_FONT_ARIAL_74 +#define LV_FONT_ARIAL_74 1 +#endif + +#if LV_FONT_ARIAL_74 + +/*----------------- + * BITMAPS + *----------------*/ + +/*Store the image of the glyphs*/ +static LV_ATTRIBUTE_LARGE_CONST const uint8_t glyph_bitmap[] = { + /* U+0020 " " */ + + /* U+0021 "!" */ + 0x69, 0x99, 0x99, 0x99, 0x2c, 0xff, 0xff, 0xff, + 0xf5, 0xcf, 0xff, 0xff, 0xff, 0x5c, 0xff, 0xff, + 0xff, 0xf5, 0xcf, 0xff, 0xff, 0xff, 0x5c, 0xff, + 0xff, 0xff, 0xf5, 0xcf, 0xff, 0xff, 0xff, 0x5c, + 0xff, 0xff, 0xff, 0xf5, 0xcf, 0xff, 0xff, 0xff, + 0x5c, 0xff, 0xff, 0xff, 0xf5, 0xcf, 0xff, 0xff, + 0xff, 0x5c, 0xff, 0xff, 0xff, 0xf5, 0xbf, 0xff, + 0xff, 0xff, 0x4a, 0xff, 0xff, 0xff, 0xf3, 0x9f, + 0xff, 0xff, 0xff, 0x28, 0xff, 0xff, 0xff, 0xf1, + 0x7f, 0xff, 0xff, 0xff, 0x5, 0xff, 0xff, 0xff, + 0xf0, 0x4f, 0xff, 0xff, 0xfe, 0x3, 0xff, 0xff, + 0xff, 0xd0, 0x2f, 0xff, 0xff, 0xfb, 0x1, 0xff, + 0xff, 0xff, 0xa0, 0xf, 0xff, 0xff, 0xf9, 0x0, + 0xff, 0xff, 0xff, 0x80, 0xd, 0xff, 0xff, 0xf7, + 0x0, 0xcf, 0xff, 0xff, 0x60, 0xb, 0xff, 0xff, + 0xf5, 0x0, 0xaf, 0xff, 0xff, 0x40, 0x9, 0xff, + 0xff, 0xf3, 0x0, 0x8f, 0xff, 0xff, 0x20, 0x7, + 0xff, 0xff, 0xf1, 0x0, 0x5f, 0xff, 0xff, 0x0, + 0x4, 0xff, 0xff, 0xf0, 0x0, 0x3f, 0xff, 0xfd, + 0x0, 0x2, 0xff, 0xff, 0xc0, 0x0, 0x1f, 0xff, + 0xfb, 0x0, 0x0, 0xff, 0xff, 0xa0, 0x0, 0xf, + 0xff, 0xf9, 0x0, 0x0, 0xef, 0xff, 0x80, 0x0, + 0xc, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0x55, 0x55, 0x55, 0x50, 0x7f, + 0xff, 0xff, 0xff, 0x7, 0xff, 0xff, 0xff, 0xf0, + 0x7f, 0xff, 0xff, 0xff, 0x7, 0xff, 0xff, 0xff, + 0xf0, 0x7f, 0xff, 0xff, 0xff, 0x7, 0xff, 0xff, + 0xff, 0xf0, 0x7f, 0xff, 0xff, 0xff, 0x0, + + /* U+0022 "\"" */ + 0x5a, 0xaa, 0xaa, 0xa8, 0x0, 0x0, 0x5a, 0xaa, + 0xaa, 0xa8, 0x9f, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xfd, 0x9f, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xfd, 0x9f, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xfd, + 0x9f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xfd, 0x9f, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xfd, 0x9f, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xfd, 0x9f, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xfd, + 0x9f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xfd, 0x7f, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xfc, 0x4f, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf9, 0x1f, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf6, + 0xe, 0xff, 0xff, 0xf4, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf3, 0xc, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xf0, 0x9, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xe0, 0x6, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xb0, + 0x3, 0xff, 0xff, 0x90, 0x0, 0x0, 0x3, 0xff, + 0xff, 0x80, 0x0, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x1, 0xff, 0xff, 0x50, 0x0, 0xdf, 0xff, 0x40, + 0x0, 0x0, 0x0, 0xef, 0xff, 0x30, + + /* U+0023 "#" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x51, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf5, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x51, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf5, 0x5, 0x55, 0x55, 0x55, 0x55, 0x8f, + 0xff, 0xff, 0x65, 0x55, 0x55, 0x55, 0x55, 0x5a, + 0xff, 0xff, 0xf5, 0x55, 0x55, 0x55, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x55, 0x55, 0x55, + 0x5e, 0xff, 0xff, 0xb5, 0x55, 0x55, 0x55, 0x55, + 0x56, 0xff, 0xff, 0xf9, 0x55, 0x55, 0x55, 0x55, + 0x51, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x51, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf5, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x51, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf5, 0x1f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x88, 0x88, 0x82, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x28, 0x88, 0x88, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0024 "$" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x26, 0x9b, 0xef, 0xff, + 0xeb, 0x96, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x8d, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2d, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0xbf, 0xff, 0xcd, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, + 0xe6, 0x0, 0x6f, 0xff, 0x60, 0x3a, 0xff, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x6f, 0xff, 0x60, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x6f, 0xff, + 0x60, 0x0, 0x6, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x60, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x60, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xff, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x60, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0x30, 0x0, 0xef, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x60, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x60, + 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x60, 0x0, 0x0, 0x4, 0xfd, 0xa8, + 0x63, 0x10, 0x1, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x6f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x6f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x6f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, + 0xfd, 0x50, 0x6f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd7, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2d, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xa4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x7c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x15, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xce, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x60, 0x4a, + 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x60, 0x0, 0x2b, 0xff, 0xff, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x60, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x60, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x21, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xfb, 0x3, 0x69, 0xcf, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xfc, 0x2f, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xfc, + 0xf, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x60, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xfb, 0xd, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf9, 0xa, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf6, 0x6, 0xff, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf2, + 0x1, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x60, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x6f, 0xff, 0x60, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0xd1, 0x0, 0x0, 0x6f, 0xff, 0x60, 0x0, + 0x1, 0xdf, 0xff, 0xff, 0xfe, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0xfd, 0x30, 0x0, 0x6f, 0xff, + 0x60, 0x0, 0x5e, 0xff, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xff, 0xff, 0xfa, 0x30, + 0x6f, 0xff, 0x60, 0x5b, 0xff, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xef, 0xff, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x3, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5d, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x49, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0x57, 0xcf, 0xff, 0xb7, 0x53, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0025 "%" */ + 0x0, 0x0, 0x0, 0x0, 0x4, 0x56, 0x54, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x27, 0x77, 0x76, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4b, 0xff, 0xff, 0xff, 0xfc, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf8, 0x20, 0x14, + 0xcf, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0x40, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0x30, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf8, + 0x20, 0x15, 0xcf, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe2, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x10, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2a, 0xff, 0xff, 0xff, 0xfb, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0x56, 0x54, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x7c, 0xdf, 0xed, 0xb6, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x1d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xb8, 0x8a, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xd2, 0x0, 0x0, 0x1c, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xc1, + 0x0, 0x0, 0x2d, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xa8, 0x8a, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xe7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x6b, 0xdf, 0xfd, 0xb6, 0x10, 0x0, 0x0, 0x0, + + /* U+0026 "&" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x34, 0x43, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x9e, 0xff, + 0xff, 0xff, 0xd9, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4c, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xa1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xd5, + 0x10, 0x14, 0xbf, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x2, + 0xdf, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xe1, 0x5, 0xff, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0xff, 0xdc, 0xff, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xef, 0xff, 0xff, 0xff, 0xff, 0xa1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4d, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x9f, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xff, 0xd3, 0x0, 0xbf, 0xff, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x6, 0x52, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0x1, 0xdf, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0xef, 0xfe, 0xb8, 0x40, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x8, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, 0xdf, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0xfe, 0x20, 0x3f, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xff, 0xfd, 0xa, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, + 0xff, 0xfb, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xd6, 0x10, + 0x0, 0x0, 0x5b, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0x4f, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x1d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdc, 0xbd, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0xff, 0xb1, 0x0, 0x0, 0x2e, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x2d, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd3, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe8, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4e, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0x8b, 0xdf, 0xff, + 0xed, 0xa7, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2c, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x0, 0x0, + + /* U+0027 "'" */ + 0x6a, 0xaa, 0xaa, 0xa7, 0xaf, 0xff, 0xff, 0xfc, + 0xaf, 0xff, 0xff, 0xfc, 0xaf, 0xff, 0xff, 0xfc, + 0xaf, 0xff, 0xff, 0xfc, 0xaf, 0xff, 0xff, 0xfc, + 0xaf, 0xff, 0xff, 0xfc, 0xaf, 0xff, 0xff, 0xfc, + 0xaf, 0xff, 0xff, 0xfc, 0x9f, 0xff, 0xff, 0xfb, + 0x6f, 0xff, 0xff, 0xf8, 0x3f, 0xff, 0xff, 0xf5, + 0x1f, 0xff, 0xff, 0xf2, 0xe, 0xff, 0xff, 0xf0, + 0xb, 0xff, 0xff, 0xd0, 0x9, 0xff, 0xff, 0xa0, + 0x6, 0xff, 0xff, 0x70, 0x3, 0xff, 0xff, 0x40, + 0x1, 0xff, 0xff, 0x10, + + /* U+0028 "(" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xfa, + + /* U+0029 ")" */ + 0x1f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+002A "*" */ + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0x10, 0x0, 0x0, 0xe, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x25, 0x0, 0x3, 0xff, 0xa4, 0x0, 0x0, + 0xcf, 0xff, 0x70, 0x0, 0x16, 0xcf, 0xf0, 0x0, + 0x8f, 0xff, 0xfe, 0x71, 0xb, 0xff, 0xf5, 0x3, + 0x9f, 0xff, 0xff, 0x50, 0xd, 0xff, 0xff, 0xff, + 0xf9, 0xaf, 0xff, 0x7b, 0xff, 0xff, 0xff, 0xfa, + 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf0, 0x4c, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x20, 0x1, 0x48, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xda, 0x61, 0x0, 0x0, 0x0, + 0x0, 0x3, 0x6f, 0xff, 0xff, 0xfc, 0x64, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xd4, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xf4, 0xa, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xfb, 0x0, 0x1f, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0x20, 0x0, + 0x6f, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0x80, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x3d, 0xff, 0xd0, 0x0, + 0x0, 0x2, 0xff, 0xfc, 0x20, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xf3, 0x0, 0x0, 0x0, 0x6, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x0, + 0x0, 0x0, 0x0, 0x2, 0x0, 0x0, 0x0, 0x0, + + /* U+002B "+" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5c, + 0xcc, 0xcc, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf1, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf1, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+002C "," */ + 0x35, 0x55, 0x55, 0x54, 0x9f, 0xff, 0xff, 0xfd, + 0x9f, 0xff, 0xff, 0xfd, 0x9f, 0xff, 0xff, 0xfd, + 0x9f, 0xff, 0xff, 0xfd, 0x9f, 0xff, 0xff, 0xfd, + 0x9f, 0xff, 0xff, 0xfd, 0x9f, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0xef, 0xfd, 0x0, 0x0, 0xff, 0xfc, + 0x0, 0x1, 0xff, 0xfa, 0x0, 0x6, 0xff, 0xf7, + 0x0, 0xc, 0xff, 0xf2, 0x0, 0x5f, 0xff, 0xc0, + 0x4, 0xff, 0xff, 0x40, 0x8f, 0xff, 0xfa, 0x0, + 0x7f, 0xff, 0xb0, 0x0, 0xc, 0xf7, 0x0, 0x0, + 0x2, 0x10, 0x0, 0x0, + + /* U+002D "-" */ + 0x58, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, + 0x88, 0x88, 0x2a, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf5, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5a, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf5, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x5a, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x50, + + /* U+002E "." */ + 0x25, 0x55, 0x55, 0x55, 0x6f, 0xff, 0xff, 0xff, + 0x6f, 0xff, 0xff, 0xff, 0x6f, 0xff, 0xff, 0xff, + 0x6f, 0xff, 0xff, 0xff, 0x6f, 0xff, 0xff, 0xff, + 0x6f, 0xff, 0xff, 0xff, 0x6f, 0xff, 0xff, 0xff, + + /* U+002F "/" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0x88, 0x88, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0030 "0" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x49, 0xbe, + 0xff, 0xfe, 0xb9, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x18, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xe8, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xfd, 0x96, + 0x66, 0x9e, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xd4, + 0x0, 0x0, 0x0, 0x5, 0xef, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xcf, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x40, + 0x0, 0xa, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xf0, 0x0, 0x4f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0x40, 0x8, 0xff, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf8, 0x0, 0xcf, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xb0, + 0xe, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xfe, 0x1, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf1, 0x4f, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0x36, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf5, 0x7f, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x79, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xf8, 0xaf, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x9b, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xfa, 0xbf, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xbc, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xfb, 0xcf, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xcc, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xfc, 0xcf, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xbb, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xfb, 0xbf, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xaa, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf9, + 0x9f, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0x87, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xf7, 0x6f, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0x54, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf3, 0x1f, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x10, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xe0, 0xc, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xfb, 0x0, 0x8f, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0x80, 0x4, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xf4, 0x0, 0xf, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xfd, 0x40, 0x0, 0x0, + 0x0, 0x4d, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xd8, + 0x55, 0x68, 0xdf, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x81, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0x9c, 0xef, + 0xff, 0xec, 0x94, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+0031 "1" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xee, 0xea, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x3d, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x6, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0x5, 0xdf, 0xff, 0xff, 0xff, 0xff, 0x6c, 0xff, + 0xff, 0xfb, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0xc, 0xff, 0xff, 0xfb, 0xcf, 0xff, 0xff, 0xff, + 0xfc, 0x20, 0xc, 0xff, 0xff, 0xfb, 0xcf, 0xff, + 0xff, 0xff, 0x70, 0x0, 0xc, 0xff, 0xff, 0xfb, + 0xcf, 0xff, 0xff, 0xa2, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xfb, 0xcf, 0xff, 0xb3, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xfb, 0xcf, 0x93, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xfb, 0x51, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xfb, + + /* U+0032 "2" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x15, 0x9c, + 0xde, 0xff, 0xed, 0xb8, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5c, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x92, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x87, 0x66, 0x8b, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xf8, 0x10, 0x0, 0x0, 0x0, 0x7, + 0xef, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xfc, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1c, 0xff, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x8f, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0xa0, 0x0, 0xdf, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xe0, + 0x1, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xf1, 0x3, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xf3, 0x5, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf3, 0x2, 0x57, + 0x9a, 0xce, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2d, + 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xef, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xfe, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, + 0xc1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xe3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xff, 0xe2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0xfa, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x31, 0x9, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf5, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf5, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf5, + + /* U+0033 "3" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x7a, 0xde, + 0xff, 0xdc, 0xa6, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6d, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xc4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xe9, 0x75, + 0x57, 0xaf, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xfd, 0x50, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xdf, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xdf, 0xff, 0xff, 0xf5, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xf2, 0x0, 0xd, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0x40, 0x0, 0xad, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x25, + 0x84, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xef, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x19, 0xff, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x26, 0xbf, 0xff, 0xff, 0xff, 0xfe, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x72, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x86, + 0x31, 0x1, 0x26, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2a, 0xff, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xfe, 0x3, 0x57, 0x9b, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0xea, 0xff, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xfc, 0x7f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xa4, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf6, 0x1f, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0x20, 0xaf, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xc0, 0x4, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0xc, 0xff, 0xff, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xd2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xff, 0xe7, 0x0, 0x0, 0x0, + 0x0, 0x4c, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xb7, + 0x66, 0x79, 0xef, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf9, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x92, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x37, 0xbd, 0xef, + 0xff, 0xdb, 0x84, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+0034 "4" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9a, 0xaa, 0xa5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf6, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xfb, 0xf, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xfe, 0x10, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0x50, 0xf, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x90, + 0x0, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xd0, 0x0, 0xf, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xff, 0xf3, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xfe, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, + 0xef, 0xff, 0xff, 0xff, 0xee, 0xee, 0xee, 0xae, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xbe, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xbe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, + + /* U+0035 "5" */ + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xfa, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x22, 0x22, 0x22, 0x20, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x14, 0x89, 0xaa, 0x97, 0x41, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf4, 0x0, 0x5c, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xb5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xf1, 0x6e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x10, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xd8, 0x41, 0x0, 0x13, + 0x7c, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0xff, 0xd4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3c, 0xff, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x4, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xf3, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x3, 0x79, + 0xbd, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x1, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xf1, 0x8c, 0xde, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xe0, 0xaf, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xa0, + 0x7f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0x60, 0x3f, 0xff, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xff, 0x10, 0xe, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xf9, 0x0, 0x9, 0xff, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xf2, 0x0, + 0x2, 0xff, 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xd2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x2, 0xaf, + 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x2, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xb7, 0x55, 0x68, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x6a, 0xce, + 0xff, 0xfe, 0xc9, 0x51, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+0036 "6" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x7a, + 0xde, 0xff, 0xec, 0xa6, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xff, 0xfd, 0x96, 0x56, 0x7b, 0xff, 0xff, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xfc, 0x30, 0x0, 0x0, 0x0, 0x2a, + 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0x0, 0x1, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xba, 0x97, 0x65, 0x0, 0x5, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x48, 0xbe, 0xff, + 0xfd, 0xb7, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x7e, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xc0, 0x0, 0x3d, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0x10, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xb0, + 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe3, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xa0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0x95, 0xff, 0xff, 0xff, 0xff, + 0xdc, 0xbd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xbf, 0xff, 0xff, + 0xfc, 0x51, 0x0, 0x0, 0x4, 0xaf, 0xff, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x50, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xdf, 0xff, 0xff, 0xff, 0x90, 0x0, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xd2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1d, 0xff, 0xff, 0xff, 0xf2, 0x0, + 0xef, 0xff, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, + 0xf9, 0x0, 0xef, 0xff, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xff, 0x0, 0xdf, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xff, 0x40, 0xdf, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0x80, + 0xcf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xc0, 0xbf, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xe0, 0xaf, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf0, 0x8f, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf0, + 0x5f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xf0, 0x3f, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xf0, 0xf, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xe0, 0xc, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xc0, + 0x8, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0x90, 0x4, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0x50, 0x0, 0xef, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xff, 0x10, 0x0, 0x8f, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0xfe, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xff, 0xf9, 0x10, 0x0, 0x0, + 0x0, 0x4d, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0x86, 0x56, 0x9e, 0xff, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x19, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x29, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0x8b, 0xef, 0xff, 0xec, 0x95, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0037 "7" */ + 0x13, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x35, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x5f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf5, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0038 "8" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x48, 0xcd, + 0xef, 0xed, 0xc8, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x92, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, + 0xff, 0xd9, 0x65, 0x68, 0xdf, 0xff, 0xff, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0xd4, 0x0, 0x0, 0x0, 0x3, 0xcf, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xfe, 0x83, 0x10, 0x13, 0x7d, 0xff, 0xff, 0xff, + 0xfc, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2a, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xa7, 0x54, 0x67, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xfe, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x7e, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xbf, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x1, 0xef, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xff, 0xf1, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf9, 0x0, + 0xe, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xff, 0x0, 0x4f, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x50, 0x7f, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xa0, 0xaf, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xd0, + 0xcf, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xf0, 0xdf, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xf0, 0xdf, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf0, 0xcf, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf0, + 0xaf, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xd0, 0x7f, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xb0, 0x4f, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0x70, 0xe, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, 0x20, + 0x8, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xfc, 0x0, 0x1, 0xff, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xff, 0xd2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xff, 0xff, 0x81, 0x0, 0x0, 0x0, + 0x0, 0x6d, 0xff, 0xff, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x1, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xc8, + 0x65, 0x67, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x69, 0xce, 0xff, 0xfe, 0xca, 0x72, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0039 "9" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x7b, 0xdf, + 0xff, 0xec, 0x95, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, + 0xff, 0xe9, 0x76, 0x78, 0xcf, 0xff, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xff, 0xd4, 0x0, 0x0, 0x0, 0x2, 0xbf, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xa0, 0x0, 0xd, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf1, 0x0, + 0x2f, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf6, 0x0, 0x5f, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xfb, 0x0, 0x8f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xfe, 0x0, 0xaf, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0x20, + 0xbf, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0x50, 0xcf, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0x70, 0xcf, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xa0, 0xbf, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xb0, + 0x9f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xd0, 0x7f, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xff, 0xe0, 0x4f, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xff, 0xf0, 0xf, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xf0, + 0xb, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xff, 0xf0, 0x5, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0xdf, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x4f, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xe7, 0x20, + 0x0, 0x0, 0x27, 0xef, 0xff, 0xff, 0xaf, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0xcb, 0xce, 0xff, 0xff, 0xff, 0xf7, + 0x6f, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x1d, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x80, 0x7f, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x1, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x8f, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x30, 0x0, 0x9f, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x2a, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0x60, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x16, 0xad, 0xef, 0xfe, 0xc8, 0x30, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf8, 0x0, + 0x3, 0x56, 0x89, 0xb6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xf3, 0x0, 0xa, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xe0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0x80, 0x0, 0x4, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0xef, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xf8, 0x10, 0x0, 0x0, 0x0, + 0x2a, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, 0xfa, 0x75, + 0x56, 0x8c, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3b, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x16, + 0xac, 0xef, 0xfe, 0xdb, 0x73, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+003A ":" */ + 0x6f, 0xff, 0xff, 0xff, 0x6f, 0xff, 0xff, 0xff, + 0x6f, 0xff, 0xff, 0xff, 0x6f, 0xff, 0xff, 0xff, + 0x6f, 0xff, 0xff, 0xff, 0x6f, 0xff, 0xff, 0xff, + 0x6f, 0xff, 0xff, 0xff, 0x25, 0x55, 0x55, 0x55, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x25, 0x55, 0x55, 0x55, 0x6f, 0xff, 0xff, 0xff, + 0x6f, 0xff, 0xff, 0xff, 0x6f, 0xff, 0xff, 0xff, + 0x6f, 0xff, 0xff, 0xff, 0x6f, 0xff, 0xff, 0xff, + 0x6f, 0xff, 0xff, 0xff, 0x6f, 0xff, 0xff, 0xff, + + /* U+003B ";" */ + 0x9f, 0xff, 0xff, 0xfd, 0x9f, 0xff, 0xff, 0xfd, + 0x9f, 0xff, 0xff, 0xfd, 0x9f, 0xff, 0xff, 0xfd, + 0x9f, 0xff, 0xff, 0xfd, 0x9f, 0xff, 0xff, 0xfd, + 0x9f, 0xff, 0xff, 0xfd, 0x35, 0x55, 0x55, 0x54, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x35, 0x55, 0x55, 0x54, 0x9f, 0xff, 0xff, 0xfd, + 0x9f, 0xff, 0xff, 0xfd, 0x9f, 0xff, 0xff, 0xfd, + 0x9f, 0xff, 0xff, 0xfd, 0x9f, 0xff, 0xff, 0xfd, + 0x9f, 0xff, 0xff, 0xfd, 0x9f, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0xef, 0xfd, 0x0, 0x0, 0xff, 0xfc, + 0x0, 0x1, 0xff, 0xfa, 0x0, 0x6, 0xff, 0xf7, + 0x0, 0xc, 0xff, 0xf2, 0x0, 0x5f, 0xff, 0xc0, + 0x4, 0xff, 0xff, 0x40, 0x8f, 0xff, 0xfa, 0x0, + 0x7f, 0xff, 0xb0, 0x0, 0xc, 0xf7, 0x0, 0x0, + 0x2, 0x10, 0x0, 0x0, + + /* U+003C "<" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x72, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xaf, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xdf, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x28, 0xff, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4b, 0xff, 0xff, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x7e, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x18, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x82, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xa3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x17, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x71, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3a, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe7, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xb4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xff, 0xfe, 0x82, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xfe, + 0x81, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xb4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd7, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x29, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x92, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6d, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe8, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4a, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x18, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x71, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xa3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x8e, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5c, 0xff, 0xff, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x39, 0xff, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x17, 0xef, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xbf, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x92, + + /* U+003D "=" */ + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf1, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf1, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf1, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf1, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf1, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf1, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf1, + + /* U+003E ">" */ + 0x82, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xc5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xe8, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0xfa, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xff, 0xfd, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x92, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x7d, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4a, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x17, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x82, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x8e, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd7, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5c, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf9, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x29, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0x9f, 0xff, 0xff, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x7d, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x6d, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x28, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4b, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe8, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x7e, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xa3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x81, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x39, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x8e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe7, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x92, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0xff, 0xfd, 0x71, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xfb, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xf9, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xd6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+003F "?" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x12, + 0x34, 0x43, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x7a, + 0xef, 0xff, 0xff, 0xff, 0xfc, 0x83, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3a, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xff, 0xfc, + 0x73, 0x10, 0x12, 0x6b, 0xff, 0xff, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, + 0xd3, 0x0, 0x0, 0x0, 0x0, 0x2, 0xbf, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xff, 0xe0, 0x0, 0xe, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0x60, 0x4, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xfd, + 0x0, 0xaf, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0xf2, 0xf, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0x52, 0xff, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xf7, 0x5f, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0x87, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf8, + 0x0, 0x12, 0x46, 0x81, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xef, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x11, 0x11, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x55, 0x55, 0x55, 0x51, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+0040 "@" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x68, 0xac, + 0xde, 0xff, 0xff, 0xed, 0xb9, 0x74, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x38, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe9, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x28, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xb2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1a, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5e, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xca, 0x86, 0x54, 0x44, 0x56, + 0x79, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x73, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0x7c, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xdf, 0xff, 0xff, 0xff, 0xfe, 0x82, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x8e, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xef, 0xff, 0xff, 0xff, 0xe7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xff, + 0xa1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xaf, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, + 0xff, 0xfe, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xfc, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2d, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1d, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x24, 0x54, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5a, 0xff, 0xff, 0xff, 0xfc, + 0x60, 0x0, 0x0, 0x0, 0x55, 0x55, 0x55, 0x10, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xdf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd4, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1b, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x8, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0xcf, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf6, 0xf, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, + 0xfc, 0x62, 0x0, 0x25, 0xbf, 0xff, 0xff, 0xf5, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xfd, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, + 0xff, 0xff, 0xe5, 0x0, 0x0, 0x0, 0x0, 0x4e, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0x50, 0x0, 0x9, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xf8, 0x0, 0x0, 0xef, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xa0, 0x0, 0x3f, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfb, + 0x0, 0x8, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xc0, 0x0, 0xcf, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xfd, 0x0, 0xf, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xd0, + 0x2, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xfc, 0x0, 0x5f, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xb0, 0x7, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf9, 0x0, + 0x9f, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0x70, 0xa, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xf3, 0x0, 0xbf, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0x0, 0xc, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xb0, 0x0, 0xcf, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xf6, 0x0, 0xc, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0x0, 0x0, 0xbf, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x90, + 0x0, 0xb, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0xaf, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x2b, 0xff, 0xff, 0xff, 0xe2, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x1a, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x2, 0x9f, 0xff, 0xff, 0xff, + 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xff, 0xb4, 0x10, 0x14, 0x9f, 0xff, 0xff, + 0xde, 0xff, 0xff, 0xff, 0xfe, 0xbc, 0xff, 0xff, + 0xff, 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe2, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd1, 0x7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa1, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xef, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x50, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6c, 0xff, 0xff, + 0xff, 0xc6, 0x0, 0x0, 0x0, 0x0, 0x2a, 0xff, + 0xff, 0xff, 0xeb, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x77, 0x77, 0x77, 0x30, 0x0, 0x9, 0xff, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x34, 0x43, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x34, 0x43, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x1e, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xfd, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xbf, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xef, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xdf, 0xff, 0xff, 0xff, 0xd5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2a, 0xff, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xcf, 0xff, 0xff, 0xff, 0xfd, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x9f, 0xff, 0xff, 0xff, 0xfe, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4b, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0x84, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0x6b, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xec, 0xa8, 0x76, 0x55, + 0x56, 0x67, 0x8b, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5c, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x8e, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0x7b, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd9, + 0x51, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x14, + 0x78, 0xac, 0xde, 0xef, 0xff, 0xfe, 0xdc, 0xb9, + 0x64, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0041 "A" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0x88, 0x88, 0x88, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xce, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf8, 0x9f, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0x44, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xf1, 0xf, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xfd, 0x0, 0xaf, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0x80, 0x4, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf3, 0x0, 0xe, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x3, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xfc, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaf, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xff, 0x10, 0x1, 0xff, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xf7, 0x0, 0x7f, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0xe0, 0xd, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0x50, + + /* U+0042 "B" */ + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0xdc, 0xb8, 0x51, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x20, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x30, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x20, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf9, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x45, 0x79, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xbf, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x8f, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf8, + 0x0, 0x8, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x8f, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xfd, 0x0, 0x8, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x8f, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xfd, 0x0, 0x8, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x8f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xf9, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xf1, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0x10, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xbf, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf9, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x45, 0x68, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x20, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x40, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x8, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x11, 0x35, 0x7b, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x8f, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6d, 0xff, 0xff, + 0xff, 0xff, 0x20, 0x8, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xfc, 0x0, + 0x8f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xf4, 0x8, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, + 0xb0, 0x8f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xff, 0x8, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xf3, 0x8f, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x58, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xf6, 0x8f, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0x68, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xf5, 0x8f, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0x38, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xf1, 0x8f, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xfc, 0x8, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0x70, 0x8f, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xff, 0xf1, 0x8, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x27, 0xef, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x8f, + 0xff, 0xff, 0xf9, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x34, 0x45, 0x7a, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x20, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe7, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xdb, 0x97, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0043 "C" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x15, 0x8a, 0xce, 0xff, 0xfe, 0xdb, 0x85, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x7d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x71, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x91, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4e, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x96, 0x31, 0x0, 0x0, 0x25, 0x9e, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6e, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xfc, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xaf, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0x10, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xb8, 0x30, + 0x0, 0xcf, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xa7, 0x30, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x10, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xc8, 0x40, 0x0, + 0x0, 0xef, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xc4, + 0x0, 0x9f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xf1, + 0x0, 0xd, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0xef, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xfc, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xdf, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x84, 0x20, 0x0, 0x2, 0x48, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x37, 0x9b, 0xde, 0xff, 0xfe, 0xdb, 0x85, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0044 "D" */ + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xed, 0xca, 0x86, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x30, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xfd, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x44, 0x57, 0x9c, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x38, 0xef, 0xff, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x9f, 0xff, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xff, 0xf1, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xff, 0x90, 0x0, 0x3f, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xff, 0x10, 0x3, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xf7, 0x0, 0x3f, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, + 0xd0, 0x3, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0x20, + 0x3f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xf7, 0x3, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xff, 0xa0, 0x3f, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xfe, 0x3, 0xff, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xf1, 0x3f, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, + 0x33, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xf5, 0x3f, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0x73, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xf8, 0x3f, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0x83, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xf9, 0x3f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0x93, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf8, 0x3f, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0x73, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xf7, 0x3f, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xff, 0x63, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf4, + 0x3f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0x13, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xf0, 0x3f, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xfc, 0x3, 0xff, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0x90, 0x3f, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xf4, + 0x3, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0x0, 0x3f, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xff, 0xb0, 0x3, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0x3f, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xfd, 0x0, 0x3, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x3f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xaf, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4a, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xfd, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x44, 0x57, 0x9c, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x20, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x30, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x20, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xa3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb6, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xed, 0xb9, 0x73, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+0045 "E" */ + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf2, 0x2, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x20, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf2, 0x2, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x20, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x2, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x20, 0x2f, 0xff, 0xff, 0xfe, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x30, 0x2, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xfe, 0x22, + 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x22, 0x22, 0x22, 0x22, 0x20, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x0, + 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x2f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x20, 0x0, 0x2f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf2, 0x0, 0x2, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xfe, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x12, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x62, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf6, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x62, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, + + /* U+0046 "F" */ + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xa1, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x1f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa1, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xa1, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x1f, + 0xff, 0xff, 0xff, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x21, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xff, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x20, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0047 "G" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x58, 0xac, 0xee, 0xff, 0xee, 0xdb, + 0x96, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x38, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xa4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd9, 0x63, 0x10, 0x0, 0x1, 0x25, 0x8d, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xff, 0xff, + 0x93, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x29, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, 0xff, + 0xa1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2c, 0xff, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0x10, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0x60, 0x0, 0xa, + 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfb, 0x60, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6c, 0x73, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x2f, 0xff, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x2f, 0xff, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x1f, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xf, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xe, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0xc, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x3f, 0xff, 0xff, + 0xfd, 0x9, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xfd, 0x6, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xfd, 0x2, 0xff, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xfd, 0x0, 0xdf, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xfd, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xfd, 0x0, 0x2f, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xfd, 0x0, + 0xb, 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xfd, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1b, + 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xff, 0xfc, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x18, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x1d, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x18, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x5b, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb1, 0x0, + 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xc9, 0x75, 0x54, 0x56, 0x7a, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3a, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x16, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd8, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x37, + 0x9b, 0xde, 0xff, 0xfe, 0xec, 0xa8, 0x41, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0048 "H" */ + 0xa, 0xaa, 0xaa, 0xa9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xaa, 0xaa, 0xaa, 0x51, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf7, 0x1f, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x71, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x1f, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x71, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xf7, 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x71, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xf7, 0x1f, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x71, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x1f, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0x71, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xf7, 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x71, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x1f, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x71, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0x71, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf7, 0x1f, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x71, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x1f, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x71, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xf7, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x71, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf7, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x71, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x1f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x71, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf7, 0x1f, 0xff, 0xff, 0xff, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x3a, 0xff, 0xff, 0xff, 0x71, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x1f, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x71, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0x71, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf7, 0x1f, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x71, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x1f, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x71, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xf7, 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x71, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xf7, 0x1f, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x71, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x1f, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0x71, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xf7, 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x71, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x1f, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x71, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0x71, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf7, 0x1f, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x71, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x1f, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x70, + + /* U+0049 "I" */ + 0x2a, 0xaa, 0xaa, 0xa8, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, + + /* U+004A "J" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0x88, 0x88, 0x88, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0x30, 0x0, 0x24, + 0x68, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xf3, 0xc, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xff, 0x30, 0xdf, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xf1, 0xc, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xff, 0x0, 0xbf, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0xe0, 0x9, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xfc, 0x0, 0x5f, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0x90, 0x2, 0xff, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0xd, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xc2, 0x0, + 0x0, 0x0, 0x2, 0xbf, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x64, + 0x34, 0x6a, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x81, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x15, 0x9c, 0xde, 0xfe, 0xdb, 0x84, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+004B "K" */ + 0x5a, 0xaa, 0xaa, 0xa4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xaa, 0xaa, 0xaa, 0xaa, 0x90, 0x8, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xff, 0xe2, 0x0, 0x8f, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, + 0xff, 0xe2, 0x0, 0x8, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xd2, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xff, 0xd1, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xff, 0xc1, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0x70, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf7, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x70, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, + 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x79, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, + 0xfd, 0xcf, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x11, + 0xef, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x10, 0x5, 0xff, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x10, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x10, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x8f, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0xff, 0x60, 0x8, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0x20, 0x8f, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xfd, + 0x0, + + /* U+004C "L" */ + 0x38, 0x88, 0x88, 0x84, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xfa, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x32, 0x7f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfa, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfa, + + /* U+004D "M" */ + 0x4a, 0xaa, 0xaa, 0xaa, 0xaa, 0xa2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xaa, 0xaa, 0xaa, + 0xaa, 0xa1, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xff, 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xf1, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0x7f, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf8, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xcf, 0xff, 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, + 0xdf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xfc, 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, + 0xff, 0xf5, 0x8f, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xf7, 0xaf, 0xff, 0xff, 0xf1, + 0x7f, 0xff, 0xff, 0xf5, 0x3f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf1, 0xaf, 0xff, + 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, 0xd, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xc0, + 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, + 0x8, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0x60, 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, + 0xff, 0xf5, 0x2, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0x10, 0xaf, 0xff, 0xff, 0xf1, + 0x7f, 0xff, 0xff, 0xf5, 0x0, 0xdf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xfb, 0x0, 0xaf, 0xff, + 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x7f, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf5, 0x0, + 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, + 0x0, 0x2f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xf0, 0x0, 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, + 0xff, 0xf5, 0x0, 0xc, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xa0, 0x0, 0xaf, 0xff, 0xff, 0xf1, + 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x7, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0x50, 0x0, 0xaf, 0xff, + 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x1, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, + 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xe0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0x90, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, + 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, + 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, + 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf4, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x40, 0x0, 0xdf, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, + 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0x90, 0x3, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xe0, 0x8, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xf3, 0xe, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xf8, 0x3f, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, + 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xfe, 0x8f, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, + 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, + 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xf1, + + /* U+004E "N" */ + 0x1a, 0xaa, 0xaa, 0xaa, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xaa, 0xaa, 0xaa, 0x62, 0xff, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xf9, 0x2f, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0x92, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf9, 0x2f, 0xff, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0x92, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xf9, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x92, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf9, 0x2f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0x92, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf9, 0x2f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0x92, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xf9, 0x2f, 0xff, 0xff, 0xf9, 0xdf, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x92, + 0xff, 0xff, 0xff, 0x92, 0xff, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xf9, 0x2f, 0xff, 0xff, + 0xf9, 0x7, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0x92, 0xff, 0xff, 0xff, 0x90, 0xc, + 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf9, + 0x2f, 0xff, 0xff, 0xf9, 0x0, 0x2f, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0x92, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x7f, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xf9, 0x2f, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0x92, 0xff, 0xff, 0xff, 0x90, 0x0, 0x2, 0xff, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf9, 0x2f, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0x92, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xf9, 0x2f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x92, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf9, 0x2f, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0x92, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf9, 0x2f, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0x92, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xf9, 0x2f, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x92, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xf9, 0x2f, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0x92, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf9, + 0x2f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0x92, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xf9, 0x2f, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xff, 0xe1, 0x0, 0x2, 0xff, 0xff, 0xff, + 0x92, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0x2f, 0xff, 0xff, 0xf9, 0x2f, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0x50, 0x2, + 0xff, 0xff, 0xff, 0x92, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xff, 0xfe, 0x10, 0x2f, 0xff, 0xff, + 0xf9, 0x2f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xfb, 0x2, 0xff, 0xff, 0xff, 0x92, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xf6, + 0x2f, 0xff, 0xff, 0xf9, 0x2f, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xff, 0xff, 0xf4, 0xff, 0xff, + 0xff, 0x92, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xf9, 0x2f, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x92, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf9, 0x2f, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x92, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0x2f, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x92, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x2f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0x92, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xff, 0xff, 0xf9, 0x2f, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, + 0x92, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xf9, 0x2f, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xff, 0x90, + + /* U+004F "O" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x14, 0x8a, 0xce, 0xff, 0xfe, 0xec, 0x97, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x6c, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xa4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb7, 0x42, + 0x0, 0x1, 0x35, 0x9d, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x61, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x29, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2b, 0xff, 0xff, 0xff, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xff, 0xc2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0xf7, 0x0, 0x2, 0xff, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xfc, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0x10, 0xb, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x40, + 0xe, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0x80, 0x1f, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xb0, 0x3f, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xd0, 0x4f, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xf0, + 0x6f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xf0, 0x7f, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xf1, 0x8f, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xf1, + 0x7f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xf0, 0x6f, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xf0, 0x3f, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xd0, + 0x1f, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xb0, 0xe, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xff, 0x80, 0xa, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xff, 0x50, 0x6, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0x10, + 0x2, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xc1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xff, 0xfe, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1a, 0xff, 0xff, 0xff, 0xff, + 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x28, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0xa6, 0x31, 0x0, 0x0, 0x24, 0x8c, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2d, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xa4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x14, 0x7a, 0xcd, 0xef, 0xfe, + 0xec, 0x97, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0050 "P" */ + 0x13, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x22, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0xa8, 0x41, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb4, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xb2, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x40, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x20, 0x0, 0x4f, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x12, + 0x47, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x4f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xcf, + 0xff, 0xff, 0xff, 0xf6, 0x0, 0x4f, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xfd, 0x0, 0x4f, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0x30, 0x4f, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0x80, 0x4f, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, + 0xc0, 0x4f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xf0, 0x4f, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xf0, 0x4f, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xf1, + 0x4f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0xf1, 0x4f, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xf1, 0x4f, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xf0, 0x4f, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xc0, 0x4f, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, + 0x90, 0x4f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0x40, 0x4f, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xfe, 0x0, 0x4f, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x4f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5d, 0xff, + 0xff, 0xff, 0xff, 0xe0, 0x0, 0x4f, 0xff, 0xff, + 0xfc, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x45, 0x69, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x30, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xe9, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xec, + 0xb8, 0x62, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x28, 0x88, 0x88, 0x85, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0051 "Q" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x15, 0x8a, 0xce, 0xff, 0xfe, 0xdc, 0x96, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x17, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe9, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0x9f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3e, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xb7, 0x42, 0x10, 0x1, 0x25, 0x8c, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xff, 0xff, 0xd6, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x19, 0xff, 0xff, + 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xff, 0xfc, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0x10, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xf4, 0x0, 0xe, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xff, 0x70, 0x1, 0xff, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xfa, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, + 0xc0, 0x5, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xff, 0x0, 0x7f, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xf0, 0x7, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0x0, 0x8f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0xf1, 0x8, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0x10, 0x7f, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xf1, + 0x6, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0x0, 0x5f, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xf0, 0x3, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfd, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0xef, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xf8, 0x0, 0xb, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x6f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xf1, 0x0, 0x2, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xd7, 0x10, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xa2, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xf9, + 0x10, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xfe, 0x40, 0x3f, 0xff, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9f, 0xff, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xef, 0xff, 0xff, 0xff, 0xc1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x6d, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, + 0xe5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xea, + 0x63, 0x10, 0x0, 0x2, 0x48, 0xdf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xef, 0xff, 0xff, 0xff, 0xfd, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2a, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x40, 0x5e, 0xff, 0xff, 0xff, 0xff, + 0xc5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0x7d, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x83, 0x0, 0x0, 0x1c, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x58, 0xbd, + 0xef, 0xff, 0xed, 0xb8, 0x52, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xaf, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2a, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0x9e, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+0052 "R" */ + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xdc, 0xa7, + 0x51, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xde, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x25, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x9f, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1c, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x18, + 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x12, 0x36, 0x8d, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x93, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x25, 0x9e, 0xff, 0xff, 0xff, 0xfe, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5e, 0xff, 0xff, 0xff, 0xfb, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xbf, 0xff, 0xff, 0xff, + 0xd2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, + 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xf1, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0x50, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, 0xe1, + 0x8, 0x88, 0x88, 0x87, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x28, 0x88, 0x88, 0x88, 0x83, + + /* U+0053 "S" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x12, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x25, 0x9c, 0xef, 0xff, + 0xff, 0xff, 0xda, 0x73, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x93, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfb, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xc1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb7, 0x52, + 0x10, 0x1, 0x13, 0x69, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xff, 0xe7, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5d, 0xff, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xb1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x8, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0xa, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xee, 0xdc, 0xb9, 0x70, 0x0, 0x7, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xff, 0xa3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x72, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x94, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd9, 0x52, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0xa5, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xc7, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6c, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x6b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x48, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0x8c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x49, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x27, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5e, 0xff, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1b, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x12, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xff, 0x27, 0xde, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xf5, 0x9f, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0x67, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xf7, 0x5f, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0x61, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf5, 0xd, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xff, 0x20, 0x7f, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0xe0, 0x1, 0xff, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf9, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xbf, 0xff, 0xff, 0xff, 0x20, 0x0, 0xe, 0xff, + 0xff, 0xff, 0xff, 0xd5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xdf, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x71, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x5c, 0xff, 0xff, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0xa7, 0x54, 0x44, 0x56, 0x9c, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xe4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2b, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x38, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xa4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x15, 0x8a, 0xcd, 0xef, 0xff, 0xfe, 0xca, 0x74, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0054 "T" */ + 0x13, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x26, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf9, 0x6f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x96, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x6f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x96, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0x88, 0x88, 0x88, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+0055 "U" */ + 0x8, 0x88, 0x88, 0x87, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0x88, 0x88, 0x88, 0x41, 0xff, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xf8, 0x1f, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0x81, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf8, 0x1f, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0x81, 0xff, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xf8, 0x1f, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0x81, 0xff, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xf8, 0x1f, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0x81, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf8, 0x1f, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0x81, 0xff, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xf8, 0x1f, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0x81, + 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xf8, 0x1f, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0x81, 0xff, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf8, + 0x1f, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0x81, 0xff, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xf8, 0x1f, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0x81, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf8, 0x1f, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0x81, 0xff, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xf8, 0x1f, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0x81, 0xff, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xf8, 0x1f, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0x81, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf8, 0x1f, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0x81, 0xff, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xf8, 0x1f, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0x81, + 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xf8, 0x1f, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0x81, 0xff, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf8, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0x70, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0x60, 0xef, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf5, 0xc, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xff, 0x30, 0xaf, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xf2, 0x8, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0x0, 0x5f, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xc0, 0x1, 0xff, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xf9, 0x0, 0xd, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x8f, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xf1, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xef, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0xfc, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xef, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xa3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x6c, 0xff, 0xff, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0xa7, 0x54, 0x45, 0x67, 0x9c, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7e, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xb6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0x7a, 0xcd, 0xef, 0xff, 0xed, + 0xca, 0x74, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+0056 "V" */ + 0x48, 0x88, 0x88, 0x87, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0x88, 0x88, 0x88, + 0x54, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xf6, 0xd, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xff, 0x0, 0x7f, 0xff, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xa0, 0x1, 0xff, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xf3, 0x0, 0xb, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x4f, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfb, + 0x0, 0xa, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xf1, 0x0, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0x60, 0x5f, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xfb, 0xa, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xf0, 0xff, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0x9f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+0057 "W" */ + 0x18, 0x88, 0x88, 0x87, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x28, + 0x88, 0x88, 0x88, 0x81, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x88, + 0x88, 0x88, 0x60, 0xff, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xf9, 0xb, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0x50, + 0x6f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0xf0, 0x2, 0xff, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xfc, 0x0, 0xe, 0xff, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0x70, 0x0, + 0xaf, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xf3, 0x0, 0x5, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xfa, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0x5c, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf1, + 0x8f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xfd, 0x4, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0x90, 0xf, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf5, 0x0, + 0xbf, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x10, 0x7, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xc0, 0x0, 0x2f, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0xef, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0x30, 0x0, 0x9, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x60, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x5, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x1, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xfe, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xa0, 0x0, 0x8, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf2, + 0x0, 0x3, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0x50, 0x0, 0x8f, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf2, 0x0, 0xf, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xf9, 0x0, 0xc, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x50, 0x4, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xc0, + 0x0, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf9, + 0x0, 0x8f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0x0, 0x3f, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xc0, 0xc, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf3, 0x7, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xff, 0x0, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x70, + 0xbf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf2, + 0x3f, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xfa, 0xf, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0x57, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xd3, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xf8, 0xaf, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x8f, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xae, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xfe, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xfe, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0058 "X" */ + 0x0, 0x9, 0xaa, 0xaa, 0xaa, 0xa3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xaa, 0xaa, 0xaa, 0xa2, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xff, 0xff, 0x30, 0x3, 0xff, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xfd, 0x0, 0xdf, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xf7, 0x8f, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xf2, 0xdf, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0xf7, 0x3, 0xff, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xfc, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xff, 0x20, 0x0, 0xd, 0xff, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x2, 0xef, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0xf2, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xff, 0xc0, 0x4f, 0xff, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0xff, 0x80, + + /* U+0059 "Y" */ + 0x48, 0x88, 0x88, 0x88, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x48, 0x88, 0x88, 0x88, + 0x42, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, + 0xf2, 0x6, 0xff, 0xff, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0xc, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0xe1, 0x0, + 0xcf, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0x90, + 0x6f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, + 0x4e, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+005A "Z" */ + 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x2, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x8f, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xfe, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, + 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xef, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2e, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xff, 0xc3, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x3a, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf3, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x3a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x30, + + /* U+005B "[" */ + 0x5, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x51, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xfa, 0x55, 0x55, 0x55, 0x51, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + + /* U+005C "\\" */ + 0x78, 0x88, 0x82, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0x60, + + /* U+005D "]" */ + 0x45, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x3b, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xab, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xab, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xfa, 0x45, 0x55, 0x55, 0x55, 0xef, 0xff, 0xff, + 0xab, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xab, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xab, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + + /* U+005E "^" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xdf, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfd, + 0x3f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf7, + 0xd, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf1, + 0x6, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xa0, + 0x0, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x40, + 0x0, 0x9f, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0x30, + 0x0, 0xef, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xa0, + 0x6, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf1, + 0xd, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf8, + + /* U+005F "_" */ + 0x4a, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0x67, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf9, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x97, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x90, + + /* U+0060 "`" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xf8, + + /* U+0061 "a" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x47, 0xac, + 0xde, 0xff, 0xfe, 0xda, 0x85, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4a, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xb4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x86, 0x65, 0x67, 0x9c, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0xfe, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x2, 0x9f, 0xff, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xfd, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0xc, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x14, 0x68, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x15, 0x9d, 0xff, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x46, 0x9b, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x26, 0x8b, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x39, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x5, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x2c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe9, 0x47, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x3e, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x96, + 0x20, 0x0, 0x7f, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc9, 0x74, + 0x10, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0x10, 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xa5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf1, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xfc, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0x10, 0x0, 0xaf, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf1, + 0x0, 0xe, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xff, 0x10, 0x0, 0xff, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0xf1, 0x0, 0x2f, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0x20, + 0x2, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xff, 0xf2, 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, 0xef, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xe4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6d, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xff, 0xfc, 0x63, 0x11, 0x13, 0x69, 0xef, + 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x2, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0xc, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe5, 0x0, + 0x9f, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x2, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x81, 0x0, 0x4, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x6d, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd8, 0x10, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x3, 0x7b, 0xde, + 0xff, 0xed, 0xa7, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x12, 0x22, 0x22, 0x20, + + /* U+0062 "b" */ + 0xa, 0xaa, 0xaa, 0xa5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x4, 0x9c, 0xef, 0xfe, 0xca, + 0x61, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x6e, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x30, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf7, 0x1, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x72, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf9, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x85, 0x56, 0x8c, 0xff, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb2, 0x0, 0x0, 0x0, + 0x2, 0xbf, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0x40, + 0x0, 0xf, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0xf5, 0x0, 0xf, 0xff, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xc0, 0x0, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0x10, 0xf, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf6, + 0x0, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xa0, 0xf, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xfd, 0x0, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xf0, 0xf, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0x10, 0xff, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf3, + 0xf, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0x30, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xf4, 0xf, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0x30, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf3, 0xf, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x10, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xf0, 0xf, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xfe, 0x0, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xb0, 0xf, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xf7, 0x0, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0x30, 0xf, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xe0, + 0x0, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xf8, 0x0, 0xf, 0xff, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xff, 0x10, 0x0, 0xff, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xff, 0x90, 0x0, 0xf, 0xff, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1c, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0x10, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xb7, + 0x55, 0x79, 0xef, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x2f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf0, 0x3f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x0, 0x2d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd3, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5a, 0xdf, + 0xff, 0xeb, 0x83, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+0063 "c" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x26, 0xac, + 0xef, 0xfe, 0xdb, 0x84, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x92, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4d, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xc8, + 0x65, 0x67, 0xbf, 0xff, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xf9, + 0x10, 0x0, 0x0, 0x0, 0x2a, 0xff, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0xe3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf4, + 0x0, 0xe, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0x80, 0x3, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xec, 0x97, 0x41, 0x0, 0x7f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2c, 0xa8, 0x64, 0x20, 0x7, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0x30, 0x3f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xf0, 0x0, 0xef, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xfb, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0x70, 0x0, 0x2f, 0xff, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xfe, + 0x50, 0x0, 0x0, 0x0, 0x2, 0xbf, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xff, 0xea, 0x76, 0x56, 0x8c, 0xff, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6d, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x6a, 0xce, 0xff, 0xed, 0xb7, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0064 "d" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xaa, 0xaa, + 0xaa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0x6a, 0xde, 0xff, 0xec, + 0x84, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd5, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb1, 0x8, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x2d, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x18, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd9, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x1d, 0xff, 0xff, + 0xff, 0xff, 0xd9, 0x75, 0x68, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xff, 0xd3, 0x0, 0x0, 0x0, 0x2, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0xe, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0x0, + 0x5f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, + 0x0, 0xcf, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xff, 0x2, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0x6, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xff, 0xa, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xff, 0xd, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xf, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0x2f, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x3f, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0x4f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0x5f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x5f, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x4f, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0x1f, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xf, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xc, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0x9, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0x5, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xff, 0x0, 0xff, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xff, 0x0, 0x9f, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0x0, 0x2f, 0xff, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xff, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xfc, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xe5, 0x0, 0x0, + 0x0, 0x2, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xe9, + 0x75, 0x67, 0xcf, 0xff, 0xff, 0xfd, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe3, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x31, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x5e, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe3, + 0x1, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x8e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x1, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x59, 0xce, 0xff, 0xfd, 0xa5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0065 "e" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0x9b, + 0xdf, 0xff, 0xec, 0xa6, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xff, 0xff, 0xd8, 0x75, 0x57, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x2e, 0xff, 0xff, 0xff, 0xfb, 0x20, 0x0, + 0x0, 0x0, 0x7, 0xef, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xcf, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0x80, 0x0, 0xb, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xfe, 0x0, 0x1, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf3, + 0x0, 0x5f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0x70, 0x9, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xfa, 0x0, 0xcf, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xd0, + 0xe, 0xff, 0xff, 0xff, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x5c, 0xff, + 0xff, 0xff, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf1, 0x1f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x21, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf3, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x31, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0xf, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdd, 0xb9, 0x75, 0x30, 0x0, 0xef, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xfc, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0xff, 0xc4, 0x0, 0x0, 0x0, 0x0, 0x2a, 0xff, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0x97, 0x55, 0x68, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3a, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x58, 0xbd, 0xef, 0xfe, 0xdc, 0x85, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0066 "f" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x6a, 0xde, + 0xff, 0xed, 0xb9, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x2d, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xc5, + 0x10, 0x0, 0x3, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x6f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x6f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0067 "g" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x24, + 0x45, 0x42, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x7b, + 0xff, 0xff, 0xff, 0xff, 0xb5, 0x0, 0x0, 0x4, + 0x77, 0x77, 0x72, 0x0, 0x0, 0x0, 0x0, 0x19, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x50, + 0x0, 0xaf, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x5e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xa0, 0xa, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc1, 0xaf, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xca, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xfe, + 0x83, 0x10, 0x13, 0x6c, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x1e, 0xff, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x3, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0xf5, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0x50, 0x2, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xdf, 0xff, 0xff, 0xff, 0xf5, 0x0, + 0xaf, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, + 0x50, 0xf, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xf5, 0x5, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xff, 0x50, 0xaf, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xf5, 0xe, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0x51, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf5, + 0x3f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x55, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xf5, 0x6f, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0x57, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xf5, 0x7f, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x56, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xf5, 0x5f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0x54, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf5, 0x1f, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0x50, 0xef, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf5, 0xa, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0x50, 0x6f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xf5, 0x1, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0x50, 0xa, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x2f, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0x1, 0xef, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x3c, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, + 0xe9, 0x41, 0x1, 0x26, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x4f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x5, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf8, 0x4, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x1, 0x9f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd4, 0x0, 0x5f, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x17, 0xcf, + 0xff, 0xff, 0xff, 0xfb, 0x50, 0x0, 0x5, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0x45, 0x54, 0x20, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xe0, 0x1, + 0x52, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xfc, + 0x0, 0x1f, 0xff, 0xeb, 0x91, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x90, 0x0, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xf5, 0x0, 0xe, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xff, 0x10, 0x0, 0xaf, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0xd2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xff, 0xe6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5d, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, + 0xb8, 0x66, 0x66, 0x8b, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x26, 0x9c, + 0xde, 0xff, 0xee, 0xc9, 0x61, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+0068 "h" */ + 0xa, 0xaa, 0xaa, 0xa5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x1, 0x5a, 0xce, + 0xff, 0xed, 0xa7, 0x30, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x2a, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc5, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf7, 0x0, 0x7f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x70, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x10, + 0x0, 0xf, 0xff, 0xff, 0xf8, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xda, 0x9a, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe7, 0x10, 0x0, 0x0, 0x5, 0xdf, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0x40, 0xf, 0xff, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xf8, 0x0, 0xff, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xc0, 0xf, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xfe, 0x0, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xf0, 0xf, 0xff, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0x20, 0xff, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf3, 0xf, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x30, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, 0xf, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x30, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0x30, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xf3, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0x30, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xf3, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0x30, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xf3, 0xf, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0x30, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xf3, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0x30, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xf3, 0xf, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0x30, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, 0xf, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x30, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, 0xf, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x30, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0x30, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xf3, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0x30, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xf3, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0x30, + + /* U+0069 "i" */ + 0x7, 0x77, 0x77, 0x73, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x22, 0x22, 0x21, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, + + /* U+006A "j" */ + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x8, 0x88, 0x88, 0x83, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0x88, 0x88, 0x83, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xb0, + 0x2, 0xfd, 0xbb, 0xef, 0xff, 0xff, 0xff, 0x70, + 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x10, + 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0xd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x17, 0xad, 0xef, 0xfd, 0xb7, 0x20, 0x0, 0x0, + + /* U+006B "k" */ + 0xa, 0xaa, 0xaa, 0xa4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0x22, 0x22, 0x22, 0x20, 0x1, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xf9, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x1, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0x60, 0x0, 0xb, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xf6, 0x0, 0xb, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0x60, 0xb, 0xff, 0xff, 0xff, 0xe3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xf6, 0xb, 0xff, 0xff, 0xff, 0xe2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0x7b, 0xff, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xde, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xd1, 0x5f, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xff, 0xd1, 0x0, + 0xbf, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0xc1, 0x0, + 0x1, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0x50, 0x0, 0x1, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xfe, 0x10, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x1, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, + 0xe1, 0x1, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xff, 0xb0, 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0x60, + + /* U+006C "l" */ + 0x1a, 0xaa, 0xaa, 0xa3, 0x2f, 0xff, 0xff, 0xf6, + 0x2f, 0xff, 0xff, 0xf6, 0x2f, 0xff, 0xff, 0xf6, + 0x2f, 0xff, 0xff, 0xf6, 0x2f, 0xff, 0xff, 0xf6, + 0x2f, 0xff, 0xff, 0xf6, 0x2f, 0xff, 0xff, 0xf6, + 0x2f, 0xff, 0xff, 0xf6, 0x2f, 0xff, 0xff, 0xf6, + 0x2f, 0xff, 0xff, 0xf6, 0x2f, 0xff, 0xff, 0xf6, + 0x2f, 0xff, 0xff, 0xf6, 0x2f, 0xff, 0xff, 0xf6, + 0x2f, 0xff, 0xff, 0xf6, 0x2f, 0xff, 0xff, 0xf6, + 0x2f, 0xff, 0xff, 0xf6, 0x2f, 0xff, 0xff, 0xf6, + 0x2f, 0xff, 0xff, 0xf6, 0x2f, 0xff, 0xff, 0xf6, + 0x2f, 0xff, 0xff, 0xf6, 0x2f, 0xff, 0xff, 0xf6, + 0x2f, 0xff, 0xff, 0xf6, 0x2f, 0xff, 0xff, 0xf6, + 0x2f, 0xff, 0xff, 0xf6, 0x2f, 0xff, 0xff, 0xf6, + 0x2f, 0xff, 0xff, 0xf6, 0x2f, 0xff, 0xff, 0xf6, + 0x2f, 0xff, 0xff, 0xf6, 0x2f, 0xff, 0xff, 0xf6, + 0x2f, 0xff, 0xff, 0xf6, 0x2f, 0xff, 0xff, 0xf6, + 0x2f, 0xff, 0xff, 0xf6, 0x2f, 0xff, 0xff, 0xf6, + 0x2f, 0xff, 0xff, 0xf6, 0x2f, 0xff, 0xff, 0xf6, + 0x2f, 0xff, 0xff, 0xf6, 0x2f, 0xff, 0xff, 0xf6, + 0x2f, 0xff, 0xff, 0xf6, 0x2f, 0xff, 0xff, 0xf6, + 0x2f, 0xff, 0xff, 0xf6, 0x2f, 0xff, 0xff, 0xf6, + 0x2f, 0xff, 0xff, 0xf6, 0x2f, 0xff, 0xff, 0xf6, + 0x2f, 0xff, 0xff, 0xf6, 0x2f, 0xff, 0xff, 0xf6, + 0x2f, 0xff, 0xff, 0xf6, 0x2f, 0xff, 0xff, 0xf6, + 0x2f, 0xff, 0xff, 0xf6, 0x2f, 0xff, 0xff, 0xf6, + 0x2f, 0xff, 0xff, 0xf6, 0x2f, 0xff, 0xff, 0xf6, + 0x2f, 0xff, 0xff, 0xf6, + + /* U+006D "m" */ + 0x2, 0x22, 0x22, 0x10, 0x0, 0x0, 0x3, 0x8b, + 0xef, 0xff, 0xdb, 0x72, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x49, 0xce, 0xff, 0xec, 0x95, 0x10, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x5d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x20, + 0x0, 0x0, 0x0, 0x6, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x81, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xa0, 0x1, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x2c, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd2, 0x0, 0x2, + 0xff, 0xff, 0xfa, 0x2, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x3e, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf2, 0x0, 0x2f, 0xff, 0xff, 0xa2, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x10, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc0, 0x2, 0xff, 0xff, 0xfa, + 0xcf, 0xff, 0xff, 0xfe, 0xb9, 0xac, 0xff, 0xff, + 0xff, 0xff, 0xf9, 0x1e, 0xff, 0xff, 0xff, 0xcb, + 0x9a, 0xcf, 0xff, 0xff, 0xff, 0xff, 0x60, 0x2f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xa3, 0x0, 0x0, + 0x1, 0x8f, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, + 0xe6, 0x10, 0x0, 0x0, 0x19, 0xff, 0xff, 0xff, + 0xfc, 0x2, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xf2, 0x2f, 0xff, 0xff, 0xff, + 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0x62, 0xff, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xf9, 0x2f, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xb2, 0xff, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xfc, 0x2f, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xd2, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xfd, 0x2f, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xd2, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xfd, + 0x2f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xd2, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xfd, 0x2f, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xd2, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xfd, 0x2f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xd2, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xfd, 0x2f, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xd2, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xfd, 0x2f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xd2, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xfd, 0x2f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xd2, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xfd, 0x2f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xd2, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xfd, 0x2f, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xd2, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xfd, + 0x2f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xd2, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xfd, 0x2f, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xd2, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xfd, 0x2f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xd2, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xfd, 0x2f, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xd0, + + /* U+006E "n" */ + 0x22, 0x22, 0x21, 0x0, 0x0, 0x0, 0x15, 0xac, + 0xef, 0xfe, 0xda, 0x72, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x29, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb3, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xfe, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0xff, 0xff, 0xfe, 0x0, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0xff, 0xff, 0xfe, 0xa, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0xff, 0xff, 0xfe, 0x8f, 0xff, 0xff, 0xff, 0xcb, + 0x9a, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x61, 0x0, + 0x0, 0x0, 0x5d, 0xff, 0xff, 0xff, 0xfe, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0x50, + 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0x90, + 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xc0, + 0xff, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xe0, + 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf0, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf2, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf2, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + + /* U+006F "o" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x15, 0x9c, + 0xef, 0xff, 0xec, 0xa6, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xd8, 0x75, 0x68, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0xfa, 0x20, 0x0, + 0x0, 0x0, 0x18, 0xff, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xe3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xdf, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xdf, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xe0, 0x0, 0x3f, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0x40, 0x7, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf9, + 0x0, 0xbf, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0xe0, 0xe, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0x11, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf4, + 0x3f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0x64, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xf7, 0x5f, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0x86, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xf8, 0x6f, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0x85, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf7, 0x4f, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0x63, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xf5, 0x1f, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0x30, 0xef, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xf0, 0xb, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xfd, 0x0, 0x7f, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0x90, 0x3, 0xff, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf4, + 0x0, 0xd, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1c, 0xff, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xfe, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2d, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0x91, 0x0, 0x0, 0x0, 0x1, 0x7f, 0xff, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x86, 0x56, 0x7b, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4b, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x59, 0xce, 0xff, 0xfe, 0xca, 0x62, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0070 "p" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x49, 0xce, + 0xff, 0xed, 0xa6, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcc, 0xcc, 0xcb, 0x0, 0x0, 0x6d, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0x30, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x0, 0x1c, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x2, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd2, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x1e, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x20, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xcf, 0xff, 0xff, 0xf9, 0x42, 0x12, 0x5a, 0xff, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0x10, 0x0, 0x0, 0x0, + 0x1b, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0x40, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xd0, + 0x0, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xf5, 0x0, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xfc, 0x0, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xff, 0x20, 0xff, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0x70, 0xff, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xb0, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xe0, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xf2, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xf4, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xf4, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xf5, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xf4, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf4, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf3, 0xff, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xf0, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xc0, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0x90, 0xff, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0x40, 0xff, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xff, 0x0, 0xff, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xfa, 0x0, 0xff, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf3, 0x0, 0xff, + 0xff, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0x20, + 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd3, 0x0, + 0x0, 0x0, 0x0, 0x2c, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xb5, 0x21, 0x2, 0x5a, 0xff, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x10, 0x0, 0x0, 0xff, 0xff, 0xff, 0x88, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc1, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x80, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x80, 0x3, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x30, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x5, 0xbf, 0xff, 0xff, + 0xff, 0xd9, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x24, + 0x44, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0071 "q" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x6a, 0xce, + 0xff, 0xec, 0x94, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd6, 0x0, 0x0, 0xac, + 0xcc, 0xcc, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc1, 0x0, + 0xdf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x1d, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x20, 0xdf, 0xff, 0xff, 0x0, 0x0, 0x1, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe1, 0xdf, 0xff, 0xff, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xff, 0xff, 0xa5, 0x31, 0x24, 0x9e, + 0xff, 0xff, 0xfc, 0xef, 0xff, 0xff, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xff, 0xb1, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x0, 0xd, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, + 0xff, 0x0, 0x4f, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xff, 0x0, 0xbf, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0xff, 0x1, 0xff, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xff, 0x5, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0x9, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0xc, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xf, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, + 0x1f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0x2f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x3f, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0x3f, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0x2f, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xe, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0xb, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0x7, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x3, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xff, 0x0, 0xef, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0x0, 0x8f, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0x0, 0x1f, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xff, 0xff, + 0x0, 0x1, 0xef, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xc2, + 0x0, 0x0, 0x0, 0x0, 0x5e, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xb5, 0x20, 0x2, 0x6c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x98, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf7, 0x8, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x30, 0x8, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x8d, 0xff, 0xff, + 0xff, 0xea, 0x40, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0x44, 0x42, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + + /* U+0072 "r" */ + 0x2, 0x22, 0x22, 0x10, 0x0, 0x1, 0x8d, 0xff, + 0xda, 0x60, 0x0, 0x3f, 0xff, 0xff, 0xa0, 0x0, + 0x5e, 0xff, 0xff, 0xff, 0xff, 0x81, 0x3f, 0xff, + 0xff, 0xa0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf7, 0x3f, 0xff, 0xff, 0xa0, 0x5f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf2, 0x3f, 0xff, 0xff, 0xa1, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x3f, + 0xff, 0xff, 0xab, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x60, 0x3f, 0xff, 0xff, 0xef, 0xff, 0xff, + 0xfc, 0xbb, 0xef, 0xff, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0xff, 0xf7, 0x10, 0x0, 0x3, 0x99, 0x0, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0073 "s" */ + 0x0, 0x0, 0x0, 0x0, 0x2, 0x69, 0xce, 0xff, + 0xfe, 0xda, 0x74, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xa3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x40, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xff, + 0xea, 0x76, 0x55, 0x69, 0xcf, 0xff, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xfd, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x2b, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0xf, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x7f, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xf6, 0x0, 0x9, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xfe, 0x70, 0x0, 0x9f, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0x64, 0x20, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xff, 0x81, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x62, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x94, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb6, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xc6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x7c, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x7b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x49, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x15, 0xae, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xaf, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2d, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x1, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0x3, 0x7a, 0xce, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, 0x8f, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x14, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf0, 0xf, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xfd, 0x0, + 0x9f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0x80, + 0x2, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xf2, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xfc, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x2a, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0xff, 0xea, + 0x76, 0x55, 0x69, 0xcf, 0xff, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x20, 0x0, 0x0, 0x0, 0x2d, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x9e, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x82, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0x7a, 0xde, 0xef, 0xfe, 0xdb, 0x74, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0074 "t" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2c, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xef, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf0, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xff, 0xb3, 0x10, 0x13, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x3d, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x5, 0x9c, 0xef, 0xfe, 0xda, 0x70, + + /* U+0075 "u" */ + 0x2f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x2f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x2f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x2f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x2f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x2f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x2f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x2f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x2f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x2f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x2f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x2f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x2f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x2f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x2f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x2f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x2f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x2f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x2f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x2f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x2f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x2f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0x2f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0x1f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, + 0x1f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, + 0xf, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, + 0xf, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, + 0xd, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, + 0xa, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, + 0x7, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, + 0x3, 0xff, 0xff, 0xff, 0xfc, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x0, 0xdf, 0xff, 0xff, 0xff, 0xe5, 0x0, 0x0, + 0x0, 0x5, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x99, + 0xac, 0xff, 0xff, 0xff, 0xf6, 0xdf, 0xff, 0xff, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0xdf, 0xff, 0xff, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0xdf, 0xff, 0xff, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x50, 0x0, 0xdf, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x2a, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x81, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x16, 0xad, 0xef, 0xfe, + 0xc9, 0x50, 0x0, 0x0, 0x0, 0x12, 0x22, 0x22, + + /* U+0076 "v" */ + 0xd, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xfe, 0x0, 0x7f, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0x90, 0x1, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf2, 0x0, + 0xb, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0xef, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0x90, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xf4, 0x0, 0x3, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xa0, 0x0, 0x8f, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x0, + 0xe, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xf5, 0x4, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xa0, 0x9f, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xfe, 0xe, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xf7, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0077 "w" */ + 0x7f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xd2, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xf8, 0xd, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x30, + 0x8f, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xe0, 0x4, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xf9, 0x0, 0xe, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x40, 0x0, + 0xaf, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xe0, 0x0, 0x5, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0x50, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xfa, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x3e, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xe0, 0xbf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xfa, 0x7, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0x60, 0x4f, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf2, + 0x0, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xfe, 0x0, 0xc, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0x90, 0x0, 0x8f, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x4, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf5, 0x0, + 0x4, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0x30, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x10, 0x0, 0xf, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xd0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0x50, 0x0, 0x2, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xc0, 0x0, 0x1, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x5f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xd0, 0x0, + 0xb, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xf5, 0x0, 0x9, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0x10, 0x1, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0x90, 0x0, 0xdf, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xf5, 0x0, 0x5f, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xfe, 0x0, 0x1f, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xa0, 0xa, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xf2, 0x5, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xfe, 0x0, 0xef, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0x70, 0xaf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xf2, 0x4f, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xfb, 0xe, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0x68, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xf2, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xfb, 0xdf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xaf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0078 "x" */ + 0x0, 0x22, 0x22, 0x22, 0x21, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x22, 0x22, + 0x22, 0x20, 0x0, 0x1e, 0xff, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xff, 0x10, 0x0, 0x3f, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xfb, 0x0, 0xd, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xf5, 0xa, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xe5, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0x5f, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0x70, + 0x7f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0xcf, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, + 0xe1, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x6f, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0x60, 0x2f, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xff, 0x20, + + /* U+0079 "y" */ + 0x58, 0x88, 0x88, 0x82, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x28, 0x88, + 0x88, 0x81, 0x6f, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xe0, 0x1f, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xff, 0x90, 0xa, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x30, + 0x4, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0xef, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0x30, 0x5, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0x80, 0xa, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xd0, 0xf, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xf2, 0x3f, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xf6, 0x8f, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xfb, 0xcf, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1b, + 0x86, 0x55, 0x7c, 0xff, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xd4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x7b, 0xef, 0xfd, 0xa5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+007A "z" */ + 0x0, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x20, 0x0, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x40, 0x1, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x1f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, 0x1, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2e, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1d, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, + 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xfd, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xfe, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xfd, 0x45, 0x67, + 0x78, 0x88, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, + 0x99, 0x99, 0x93, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x68, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x8f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x68, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf6, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x60, + + /* U+007B "{" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x8b, + 0xde, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xcf, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xfd, + 0xba, 0xa0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xf8, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3e, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x49, 0xff, 0xff, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xff, 0xfd, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xff, 0xa1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xd4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0xc4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0xff, 0xa1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, + 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x5a, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xf8, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0xfd, 0xba, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xdf, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0x9b, 0xef, 0xff, 0xf0, + + /* U+007C "|" */ + 0x3f, 0xff, 0xff, 0x73, 0xff, 0xff, 0xf7, 0x3f, + 0xff, 0xff, 0x73, 0xff, 0xff, 0xf7, 0x3f, 0xff, + 0xff, 0x73, 0xff, 0xff, 0xf7, 0x3f, 0xff, 0xff, + 0x73, 0xff, 0xff, 0xf7, 0x3f, 0xff, 0xff, 0x73, + 0xff, 0xff, 0xf7, 0x3f, 0xff, 0xff, 0x73, 0xff, + 0xff, 0xf7, 0x3f, 0xff, 0xff, 0x73, 0xff, 0xff, + 0xf7, 0x3f, 0xff, 0xff, 0x73, 0xff, 0xff, 0xf7, + 0x3f, 0xff, 0xff, 0x73, 0xff, 0xff, 0xf7, 0x3f, + 0xff, 0xff, 0x73, 0xff, 0xff, 0xf7, 0x3f, 0xff, + 0xff, 0x73, 0xff, 0xff, 0xf7, 0x3f, 0xff, 0xff, + 0x73, 0xff, 0xff, 0xf7, 0x3f, 0xff, 0xff, 0x73, + 0xff, 0xff, 0xf7, 0x3f, 0xff, 0xff, 0x73, 0xff, + 0xff, 0xf7, 0x3f, 0xff, 0xff, 0x73, 0xff, 0xff, + 0xf7, 0x3f, 0xff, 0xff, 0x73, 0xff, 0xff, 0xf7, + 0x3f, 0xff, 0xff, 0x73, 0xff, 0xff, 0xf7, 0x3f, + 0xff, 0xff, 0x73, 0xff, 0xff, 0xf7, 0x3f, 0xff, + 0xff, 0x73, 0xff, 0xff, 0xf7, 0x3f, 0xff, 0xff, + 0x73, 0xff, 0xff, 0xf7, 0x3f, 0xff, 0xff, 0x73, + 0xff, 0xff, 0xf7, 0x3f, 0xff, 0xff, 0x73, 0xff, + 0xff, 0xf7, 0x3f, 0xff, 0xff, 0x73, 0xff, 0xff, + 0xf7, 0x3f, 0xff, 0xff, 0x73, 0xff, 0xff, 0xf7, + 0x3f, 0xff, 0xff, 0x73, 0xff, 0xff, 0xf7, 0x3f, + 0xff, 0xff, 0x73, 0xff, 0xff, 0xf7, 0x3f, 0xff, + 0xff, 0x73, 0xff, 0xff, 0xf7, 0x3f, 0xff, 0xff, + 0x73, 0xff, 0xff, 0xf7, 0x3f, 0xff, 0xff, 0x73, + 0xff, 0xff, 0xf7, 0x3f, 0xff, 0xff, 0x73, 0xff, + 0xff, 0xf7, 0x3f, 0xff, 0xff, 0x73, 0xff, 0xff, + 0xf7, 0x3f, 0xff, 0xff, 0x73, 0xff, 0xff, 0xf7, + 0x3f, 0xff, 0xff, 0x73, 0xff, 0xff, 0xf7, 0x3f, + 0xff, 0xff, 0x73, 0xff, 0xff, 0xf7, 0x3f, 0xff, + 0xff, 0x70, + + /* U+007D "}" */ + 0x4f, 0xff, 0xed, 0xb8, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xfb, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x3a, + 0xab, 0xdf, 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xbf, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xb1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xfe, 0x72, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3d, 0xff, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7e, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7e, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2d, + 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0x93, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xc2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xcf, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x3a, 0xab, 0xef, + 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0xfa, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xed, 0xa6, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+007E "~" */ + 0x0, 0x0, 0x0, 0x58, 0xab, 0xba, 0x85, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x41, 0x0, 0x2, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x72, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xf1, 0x0, 0x7f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xf1, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe8, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x2b, 0xff, 0xf1, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0x62, 0x0, 0x0, 0x39, 0xff, 0xff, 0xf1, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xec, 0xdf, 0xff, 0xff, + 0xff, 0xf1, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf1, 0xdf, 0xff, 0xfe, + 0x83, 0x10, 0x14, 0x8c, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0xdf, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x28, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x50, 0xdf, 0xd2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd2, 0x0, 0xdc, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x0, + 0x0, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x48, 0xbe, 0xff, 0xec, + 0x94, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00A0 " " */ + + /* U+00A3 "£" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x23, 0x44, 0x32, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0x8c, 0xff, 0xff, 0xff, 0xff, + 0xb7, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6d, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xa2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xff, 0xd8, 0x31, 0x1, + 0x26, 0xcf, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x4e, 0xff, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xfe, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1c, 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xeb, 0x96, 0x30, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x15, 0x55, 0x55, 0x56, 0xff, 0xff, 0xff, + 0xc5, 0x55, 0x55, 0x55, 0x55, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xf9, 0x2, 0x34, + 0x43, 0x21, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1b, 0xff, 0xff, + 0xff, 0xcf, 0xff, 0xff, 0xff, 0xfe, 0xb8, 0x52, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xb4, 0x0, + 0x5e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc9, 0x64, 0x33, 0x47, + 0xaf, 0xff, 0xa0, 0xa, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x7, 0xff, + 0xff, 0xfe, 0xa7, 0x32, 0x10, 0x12, 0x47, 0xbe, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x10, 0x1f, 0xff, 0xa4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0x7b, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe8, 0x20, 0x0, 0xaa, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x37, 0xad, 0xff, 0xed, 0xa7, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+00A4 "¤" */ + 0x0, 0x0, 0x11, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x20, 0x0, 0x0, 0x0, 0x1d, 0xc1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbe, 0x20, 0x0, 0x0, 0x1c, 0xff, + 0xc1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xfe, 0x20, 0x0, + 0xc, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x27, 0xad, + 0xef, 0xed, 0xb7, 0x20, 0x0, 0x0, 0xbf, 0xff, + 0xfd, 0x10, 0xc, 0xff, 0xff, 0xff, 0xd1, 0x4, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc5, 0x0, + 0xbf, 0xff, 0xff, 0xfd, 0x10, 0x8f, 0xff, 0xff, + 0xff, 0xdb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0xcf, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xff, 0xfc, 0x61, 0x0, + 0x1, 0x6c, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xe4, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xef, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xd2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xdf, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x4, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xfd, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2d, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xfe, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x4e, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, + 0xc6, 0x10, 0x0, 0x16, 0xcf, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x8, 0xff, 0xff, 0xff, 0xfc, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xbb, 0xff, 0xff, 0xff, 0xfa, 0x0, 0xcf, 0xff, + 0xff, 0xfc, 0x10, 0x3b, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x40, 0xb, 0xff, 0xff, 0xff, 0xd1, + 0x0, 0xcf, 0xff, 0xfc, 0x10, 0x0, 0x2, 0x7a, + 0xde, 0xfe, 0xdb, 0x72, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xd1, 0x0, 0x1, 0xdf, 0xfc, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xe2, 0x0, 0x0, 0x1, 0xdc, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xe2, 0x0, 0x0, + 0x0, 0x1, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x0, 0x0, + + /* U+00A5 "¥" */ + 0xaf, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xff, 0xc0, 0x2f, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xff, 0x30, 0x8, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x3f, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xb0, 0x0, 0xbf, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xf3, 0x3, 0xff, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xfb, + 0xb, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0x6f, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x35, 0x55, + 0x55, 0x55, 0x55, 0x55, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xc5, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x40, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0x88, 0x88, 0x87, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+00A6 "¦" */ + 0x3f, 0xff, 0xff, 0x73, 0xff, 0xff, 0xf7, 0x3f, + 0xff, 0xff, 0x73, 0xff, 0xff, 0xf7, 0x3f, 0xff, + 0xff, 0x73, 0xff, 0xff, 0xf7, 0x3f, 0xff, 0xff, + 0x73, 0xff, 0xff, 0xf7, 0x3f, 0xff, 0xff, 0x73, + 0xff, 0xff, 0xf7, 0x3f, 0xff, 0xff, 0x73, 0xff, + 0xff, 0xf7, 0x3f, 0xff, 0xff, 0x73, 0xff, 0xff, + 0xf7, 0x3f, 0xff, 0xff, 0x73, 0xff, 0xff, 0xf7, + 0x3f, 0xff, 0xff, 0x73, 0xff, 0xff, 0xf7, 0x3f, + 0xff, 0xff, 0x73, 0xff, 0xff, 0xf7, 0x3f, 0xff, + 0xff, 0x73, 0xff, 0xff, 0xf7, 0x3f, 0xff, 0xff, + 0x73, 0xff, 0xff, 0xf7, 0x3f, 0xff, 0xff, 0x73, + 0xff, 0xff, 0xf7, 0x3f, 0xff, 0xff, 0x73, 0xff, + 0xff, 0xf7, 0x16, 0x66, 0x66, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x16, 0x66, 0x66, 0x33, + 0xff, 0xff, 0xf7, 0x3f, 0xff, 0xff, 0x73, 0xff, + 0xff, 0xf7, 0x3f, 0xff, 0xff, 0x73, 0xff, 0xff, + 0xf7, 0x3f, 0xff, 0xff, 0x73, 0xff, 0xff, 0xf7, + 0x3f, 0xff, 0xff, 0x73, 0xff, 0xff, 0xf7, 0x3f, + 0xff, 0xff, 0x73, 0xff, 0xff, 0xf7, 0x3f, 0xff, + 0xff, 0x73, 0xff, 0xff, 0xf7, 0x3f, 0xff, 0xff, + 0x73, 0xff, 0xff, 0xf7, 0x3f, 0xff, 0xff, 0x73, + 0xff, 0xff, 0xf7, 0x3f, 0xff, 0xff, 0x73, 0xff, + 0xff, 0xf7, 0x3f, 0xff, 0xff, 0x73, 0xff, 0xff, + 0xf7, 0x3f, 0xff, 0xff, 0x73, 0xff, 0xff, 0xf7, + 0x3f, 0xff, 0xff, 0x73, 0xff, 0xff, 0xf7, 0x3f, + 0xff, 0xff, 0x73, 0xff, 0xff, 0xf7, 0x3f, 0xff, + 0xff, 0x70, + + /* U+00A7 "§" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x6a, 0xde, + 0xff, 0xed, 0xa7, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4b, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xe8, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xfb, 0x75, + 0x56, 0x9e, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xb2, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xfe, + 0xcb, 0x96, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, + 0xfa, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xfe, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0x91, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x17, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xef, 0xff, 0xff, 0xfe, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xe4, + 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, + 0xb1, 0x0, 0x4, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x1, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x30, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x4d, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb1, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xd2, 0x0, 0xd, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xff, 0xff, 0xe2, 0x0, 0xef, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2c, 0xff, 0xff, 0xff, 0xff, 0xd0, 0xd, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0x80, + 0xbf, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, + 0xff, 0x17, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xf6, 0x3f, 0xff, 0xff, 0xfe, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xa0, 0xbf, 0xff, 0xff, + 0xfe, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xfc, 0x3, 0xff, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xd0, + 0x7, 0xff, 0xff, 0xff, 0xff, 0xc2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xfd, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xc0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xa1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x3, 0xef, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x1, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x30, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5e, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x7f, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x19, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd6, 0xcf, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2b, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2d, + 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1c, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x24, 0x69, 0xbc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0x60, 0x0, 0x6, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0xef, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xff, 0xf8, 0x10, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xc9, 0x87, + 0x9b, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x28, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x47, 0xbd, 0xef, 0xfe, + 0xdb, 0x73, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00A8 "¨" */ + 0x46, 0x66, 0x66, 0x60, 0x0, 0x0, 0x1, 0x66, + 0x66, 0x66, 0x2c, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0x7c, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xf7, 0xcf, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0x7c, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf7, 0xcf, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0x7c, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xf7, + + /* U+00A9 "©" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x15, 0x8b, 0xde, 0xff, 0xfe, 0xca, + 0x84, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x27, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xc7, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xa2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0xa9, 0x88, 0x9a, 0xbe, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xef, + 0xff, 0xff, 0xff, 0xd7, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x6b, 0xff, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xfa, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x7e, + 0xff, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xb2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xbf, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xfd, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xfc, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfd, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x59, 0xce, 0xff, + 0xfe, 0xc8, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x18, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x10, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xf7, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x20, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0xdf, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xfc, 0x73, 0x10, 0x13, 0x7d, + 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0x70, 0x0, 0x3f, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xe5, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfd, 0x0, 0x8, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf3, 0x0, 0xef, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0x80, 0x2f, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xfe, 0xb6, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xfc, 0x5, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x22, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf0, 0x9f, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x2c, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf4, 0xdf, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x6e, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xf7, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x8f, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf8, 0xef, 0xff, 0x90, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0x7e, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xf6, 0xcf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0x4a, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1a, 0x51, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf2, + 0x7f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xfc, 0x30, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0x3, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xb0, 0xf, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf8, 0x0, 0xaf, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0x30, 0x5, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xfc, 0x20, 0x0, 0x0, 0x0, 0x1, 0xaf, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xd0, 0x0, 0xe, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xa5, 0x20, 0x1, + 0x5a, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf7, 0x0, 0x0, 0x7f, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x4, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x39, 0xdf, 0xff, 0xff, 0xfd, 0xa5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x23, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xd2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1a, 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xfb, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5e, 0xff, 0xff, 0xfe, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0xa2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xdf, + 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4e, 0xff, 0xff, + 0xff, 0xfc, 0x73, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x14, 0x9e, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xca, + 0x88, 0x78, 0x9b, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xa1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6d, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xae, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x71, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0x69, 0xbd, 0xef, 0xff, + 0xed, 0xa8, 0x51, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00AA "ª" */ + 0x0, 0x0, 0x0, 0x5, 0xad, 0xef, 0xec, 0x71, + 0x0, 0x0, 0xbf, 0xff, 0xf8, 0x0, 0x0, 0x5, + 0xef, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x13, 0xff, 0xff, 0xf0, 0x0, + 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xc8, 0xff, 0xff, 0xb0, 0x0, 0x6f, 0xff, 0xff, + 0xf9, 0x31, 0x14, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0x70, 0x1, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xff, 0x30, 0x8, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0x0, 0xe, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xfc, 0x0, + 0x3f, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xf9, 0x0, 0x6f, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xf5, 0x0, 0xaf, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xf2, 0x0, 0xbf, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xf0, 0x0, 0xcf, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xc0, + 0x0, 0xdf, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0x90, 0x0, 0xdf, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0x90, 0x0, 0xcf, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xc0, 0x0, + 0xbf, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xf0, 0x0, 0x9f, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xf3, 0x0, 0x5f, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf7, 0x0, 0x2f, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xfb, 0x0, 0xc, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0x0, 0x6, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x1, 0xdf, 0xff, 0xff, 0xff, 0x40, 0x0, 0xef, + 0xff, 0xff, 0x30, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x5f, 0xff, 0xff, 0xf8, + 0x20, 0x16, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xd0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc5, 0xff, 0xff, 0xf3, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x10, 0x9c, + 0xcc, 0xc7, 0x0, 0x0, 0x6, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xa1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xbd, 0xff, 0xec, 0x82, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+00AB "«" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8c, 0xcc, + 0xc7, 0x0, 0x0, 0x0, 0x0, 0x9c, 0xcc, 0xc8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfa, + + /* U+00AC "¬" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf1, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf1, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf1, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0x88, 0x88, 0x80, + + /* U+00AD "­" */ + 0x58, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, + 0x88, 0x88, 0x2a, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf5, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5a, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf5, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x5a, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x50, + + /* U+00AE "®" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x15, 0x8b, 0xde, 0xff, 0xfe, 0xca, + 0x84, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x27, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xc7, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xa2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0xa9, 0x88, 0x9a, 0xbe, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xef, + 0xff, 0xff, 0xff, 0xd7, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x6b, 0xff, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xfa, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x7e, + 0xff, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xb2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xbf, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xfd, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xfc, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xef, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xfd, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0xdb, 0x85, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0x50, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xf7, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0xdf, 0xff, 0xf1, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0x70, 0x0, 0x3f, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x2, 0x59, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfd, 0x0, 0x8, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xf3, 0x0, 0xef, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0x80, 0x2f, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xfc, 0x5, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xf0, 0x9f, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0x2c, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xf4, 0xdf, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x1, 0x36, 0xbf, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0x6e, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xf7, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x8f, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xf8, 0xef, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x61, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0x7e, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf1, + 0x0, 0x13, 0x7e, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xf6, 0xcf, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0x0, 0x0, 0x0, 0x1c, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0x4a, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x1d, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xf2, + 0x7f, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0x3, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xb0, 0xf, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xf8, 0x0, 0xaf, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0x30, 0x5, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xd0, 0x0, 0xe, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xf7, 0x0, 0x0, 0x7f, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0xa, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x7b, + 0xbb, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xbb, 0xbb, 0x80, 0x0, 0x5, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xd2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1a, 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xfb, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5e, 0xff, 0xff, 0xfe, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0xa2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xdf, + 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4e, 0xff, 0xff, + 0xff, 0xfc, 0x73, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x14, 0x9e, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xca, + 0x88, 0x78, 0x9b, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xa1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6d, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xae, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x71, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0x69, 0xbd, 0xef, 0xff, + 0xed, 0xa8, 0x51, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00B0 "°" */ + 0x0, 0x0, 0x0, 0x4, 0x9c, 0xdc, 0xb7, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5e, 0xff, 0xff, + 0xff, 0xff, 0xb2, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x7f, 0xff, 0xfe, 0x72, 0x1, + 0x4a, 0xff, 0xff, 0xf2, 0x0, 0x1f, 0xff, 0xfc, + 0x10, 0x0, 0x0, 0x4, 0xff, 0xff, 0xb0, 0x9, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0x20, 0xef, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xf7, 0x1f, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xa2, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xfc, 0x3f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xc1, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xfb, 0xe, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0x80, 0x9f, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xf3, 0x2, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x3e, 0xff, 0xfc, 0x0, 0x9, 0xff, + 0xff, 0xd5, 0x0, 0x2, 0x8f, 0xff, 0xff, 0x30, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xef, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x6b, 0xef, 0xed, 0x94, 0x0, + 0x0, 0x0, + + /* U+00B1 "±" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf1, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf1, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5c, 0xcc, 0xcc, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf1, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf1, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + + /* U+00B2 "²" */ + 0x0, 0x0, 0x0, 0x2, 0x7b, 0xde, 0xff, 0xec, + 0x96, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd1, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x1e, 0xff, 0xff, 0xfe, 0x86, 0x45, 0x7d, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x8f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xe0, + 0x0, 0xef, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xf1, 0x3, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf3, + 0x0, 0x12, 0x46, 0x81, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1c, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xdf, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xbf, 0xff, 0xff, + 0xfe, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3e, 0xff, 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xd2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xfb, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xfd, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x62, + 0x0, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf6, 0x6, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, + 0xd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf6, 0xf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, + + /* U+00B3 "³" */ + 0x0, 0x0, 0x0, 0x49, 0xce, 0xff, 0xed, 0xa7, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x4, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb2, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, 0xef, + 0xff, 0xff, 0xa3, 0x0, 0x27, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x7f, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xfd, 0x0, 0xd, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf0, + 0x0, 0x7a, 0xdf, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x3, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x25, 0xcf, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xfb, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xfe, 0x81, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0xff, 0xff, 0xe3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x8f, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xf4, 0x13, 0x46, + 0x85, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0x4a, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, + 0x0, 0xef, 0xff, 0xff, 0xb3, 0x0, 0x0, 0x2a, + 0xff, 0xff, 0xff, 0x90, 0x5, 0xff, 0xff, 0xff, + 0xfe, 0xcc, 0xef, 0xff, 0xff, 0xff, 0xe0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe2, 0x0, 0x0, 0x6, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb1, 0x0, 0x0, 0x0, + 0x1, 0x7d, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x46, 0x77, + 0x65, 0x30, 0x0, 0x0, 0x0, 0x0, + + /* U+00B5 "µ" */ + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x50, 0x0, + 0x1, 0x6d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xed, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xac, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x78, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0xc, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc1, 0xc, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x3, 0xdf, 0xff, 0xff, + 0xff, 0xff, 0xe7, 0x0, 0xc, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x4, 0x9d, 0xff, + 0xfd, 0xa6, 0x0, 0x0, 0x1, 0x22, 0x22, 0x20, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00B6 "¶" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x23, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x2, 0x7a, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x5c, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x2, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x0, 0x3, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, + 0x0, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x90, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x90, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x90, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x1c, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x59, + 0xef, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x13, 0x4b, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x90, + 0x0, 0x0, + + /* U+00B7 "·" */ + 0x15, 0x55, 0x55, 0x55, 0x5, 0xff, 0xff, 0xff, + 0xf1, 0x5f, 0xff, 0xff, 0xff, 0x15, 0xff, 0xff, + 0xff, 0xf1, 0x5f, 0xff, 0xff, 0xff, 0x15, 0xff, + 0xff, 0xff, 0xf1, 0x5f, 0xff, 0xff, 0xff, 0x15, + 0xff, 0xff, 0xff, 0xf1, + + /* U+00BB "»" */ + 0x6c, 0xcc, 0xca, 0x0, 0x0, 0x0, 0x0, 0x5c, + 0xcc, 0xca, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+00BD "½" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x17, 0x88, + 0x88, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xef, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1a, 0xff, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xb2, 0xf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xc5, 0x0, 0xf, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, + 0x93, 0x0, 0x0, 0xf, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x7b, 0xde, 0xff, 0xed, 0xa6, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xfe, 0x86, 0x45, + 0x7c, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xef, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x12, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4e, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xbf, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4e, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xbf, 0xff, + 0xff, 0xfd, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2d, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfd, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xfd, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x52, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0384 "΄" */ + 0x0, 0x0, 0x1, 0x11, 0x11, 0x11, 0x10, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xff, 0x20, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, + + /* U+0386 "Ά" */ + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xd1, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xbc, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xf7, 0x7f, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0x32, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xf0, 0xd, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x11, 0x11, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xfb, 0x0, 0x8f, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0x60, 0x2, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf1, 0x0, 0xc, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x1, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xfc, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaf, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xff, 0x10, 0x1, 0xff, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x7f, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0xe0, 0xd, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0x50, + + /* U+0388 "Έ" */ + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xfd, 0x10, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf9, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x20, 0x0, 0xf, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x11, 0x11, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf9, 0x22, 0x22, + 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x22, 0x22, 0x22, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xf9, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x0, + + /* U+0389 "Ή" */ + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0x90, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xfe, 0x10, 0x0, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xff, 0x30, 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x1f, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf9, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0x90, 0x0, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xf9, 0x0, 0x7f, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0x90, 0xe, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xf9, 0x7, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0x90, 0xef, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf9, 0x1, + 0x11, 0x11, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x39, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0x90, + + /* U+038A "Ί" */ + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0xfe, 0x10, 0x0, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0x30, + 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x7f, 0xff, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, + 0xe, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xf0, 0x7, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, + 0x0, 0xef, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0xf0, 0x1, 0x11, 0x11, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, + + /* U+038C "Ό" */ + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x59, 0xbd, 0xef, + 0xff, 0xed, 0xb9, 0x62, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, + 0x28, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe8, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x4b, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x2b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xe1, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xea, 0x63, 0x10, 0x0, 0x13, + 0x6a, 0xef, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xb4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xf6, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xff, 0xff, 0xd4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xdf, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x1, 0x11, 0x11, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xff, 0xff, 0xc2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xdf, 0xff, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xa3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd9, 0x52, 0x0, 0x0, 0x2, 0x59, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1a, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfb, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x17, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe8, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x58, 0xbd, + 0xef, 0xff, 0xed, 0xb9, 0x62, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+038E "Ύ" */ + 0x0, 0x0, 0x0, 0x11, 0x11, 0x11, 0x11, 0x0, + 0x0, 0x11, 0x11, 0x11, 0x11, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x11, 0x11, + 0x11, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0xd, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x8, 0xff, 0xff, 0xfd, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xff, 0xe1, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x6, 0xff, 0xff, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0x30, 0x1, 0xef, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xfc, 0x0, + 0x9f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, + 0xf6, 0x3f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xff, 0xec, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0x88, 0x88, 0x88, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+038F "Ώ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x58, 0xbc, 0xde, + 0xee, 0xdc, 0x97, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x2, + 0x8d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0x2a, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x3, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0x63, 0x10, 0x1, 0x25, 0x9e, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0x60, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0xe, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x11, 0x11, 0x10, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xff, 0xd2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xfe, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xe4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2d, 0xff, + 0xff, 0xfe, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xdf, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfe, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0x33, 0x33, 0x33, 0x33, 0x34, 0xef, 0xff, 0xff, + 0xfe, 0x60, 0x0, 0x0, 0x0, 0x5, 0xdf, 0xff, + 0xff, 0xff, 0x53, 0x33, 0x33, 0x33, 0x33, 0x30, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf3, + + /* U+0390 "ΐ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0x90, 0xe, 0xff, 0xff, 0xf5, 0xef, 0xff, + 0xff, 0x50, 0x0, 0xb, 0xff, 0xff, 0xd0, 0x0, + 0xef, 0xff, 0xff, 0x5e, 0xff, 0xff, 0xf5, 0x0, + 0x3, 0xff, 0xff, 0xf2, 0x0, 0xe, 0xff, 0xff, + 0xf5, 0xef, 0xff, 0xff, 0x50, 0x0, 0xbf, 0xff, + 0xf6, 0x0, 0x0, 0xef, 0xff, 0xff, 0x5e, 0xff, + 0xff, 0xf5, 0x0, 0x2f, 0xff, 0xfa, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xf5, 0xef, 0xff, 0xff, 0x50, + 0xa, 0xff, 0xfd, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0x5d, 0xee, 0xee, 0xe4, 0x1, 0xee, 0xee, + 0x30, 0x0, 0x0, 0xc, 0xee, 0xee, 0xe5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0x22, 0x22, 0x21, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+0391 "Α" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0x88, 0x88, 0x88, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xce, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xf8, 0x9f, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0x44, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xf1, 0xf, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xfd, 0x0, 0xaf, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0x80, 0x4, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf3, 0x0, 0xe, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x3, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xfc, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaf, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xff, 0x10, 0x1, 0xff, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xf7, 0x0, 0x7f, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0xe0, 0xd, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0x50, + + /* U+0392 "Β" */ + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0xdc, 0xb8, 0x51, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x20, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x30, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x20, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf9, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x45, 0x79, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xbf, 0xff, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x8f, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf8, + 0x0, 0x8, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x8f, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xfd, 0x0, 0x8, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x8f, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xfd, 0x0, 0x8, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x8f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xf9, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xf1, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0x10, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xbf, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf9, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x45, 0x68, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x20, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x40, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x8, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x11, 0x35, 0x7b, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x8f, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6d, 0xff, 0xff, + 0xff, 0xff, 0x20, 0x8, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xfc, 0x0, + 0x8f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xf4, 0x8, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, + 0xb0, 0x8f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xff, 0x8, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xf3, 0x8f, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x58, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xf6, 0x8f, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0x68, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xf5, 0x8f, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0x38, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xf1, 0x8f, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xfc, 0x8, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0x70, 0x8f, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xff, 0xf1, 0x8, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x27, 0xef, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x8f, + 0xff, 0xff, 0xf9, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x34, 0x45, 0x7a, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x20, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe7, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfb, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xdb, 0x97, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+0393 "Γ" */ + 0x3, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf0, 0x1f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x1, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x1f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf0, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x1, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x88, 0x88, 0x88, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+0394 "Δ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0x88, 0x88, 0x88, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xcf, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf8, 0xaf, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0x45, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xf0, 0xf, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xfc, 0x0, 0xaf, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x80, 0x5, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf2, 0x0, 0xf, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x4, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xd3, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x34, 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x10, 0x1, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf7, 0x0, 0x7f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0xe, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, + + /* U+0395 "Ε" */ + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf2, 0x2, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x20, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf2, 0x2, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x20, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x2, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x20, 0x2f, 0xff, 0xff, 0xfe, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x30, 0x2, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xfe, 0x22, + 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x22, 0x22, 0x22, 0x22, 0x20, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x0, + 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x2f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x20, 0x0, 0x2f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf2, 0x0, 0x2, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xfe, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x12, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x62, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf6, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x62, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf6, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, + + /* U+0396 "Ζ" */ + 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x2, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x8f, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xfe, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, + 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2e, 0xff, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xef, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2e, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xff, 0xc3, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x3a, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf3, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x3a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x30, + + /* U+0397 "Η" */ + 0xa, 0xaa, 0xaa, 0xa9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xaa, 0xaa, 0xaa, 0x51, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf7, 0x1f, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x71, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x1f, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x71, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xf7, 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x71, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xf7, 0x1f, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x71, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x1f, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0x71, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xf7, 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x71, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x1f, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x71, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0x71, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf7, 0x1f, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x71, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x1f, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x71, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xf7, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x71, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf7, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x71, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x1f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x71, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf7, 0x1f, 0xff, 0xff, 0xff, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x3a, 0xff, 0xff, 0xff, 0x71, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x1f, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x71, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0x71, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf7, 0x1f, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x71, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x1f, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x71, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xf7, 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x71, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xf7, 0x1f, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x71, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x1f, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0x71, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xf7, 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x71, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x1f, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x71, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0x71, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf7, 0x1f, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x71, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x1f, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x70, + + /* U+0398 "Θ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x14, 0x8a, 0xce, 0xff, 0xfe, 0xec, 0x97, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x6c, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xa4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb7, 0x42, + 0x0, 0x1, 0x35, 0x9d, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x61, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x29, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2b, 0xff, 0xff, 0xff, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xff, 0xc2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0xf7, 0x0, 0x2, 0xff, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xfc, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0x10, 0xb, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x40, + 0xe, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0x80, 0x1f, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xb0, 0x3f, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xd0, 0x4f, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x2, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xf0, + 0x6f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xf0, 0x7f, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xf1, 0x8f, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xf1, + 0x7f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xf0, 0x6f, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xf0, 0x3f, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xd0, + 0x1f, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xb0, 0xe, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xff, 0x80, 0xa, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xff, 0x50, 0x6, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0x10, + 0x2, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xc1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xff, 0xfe, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1a, 0xff, 0xff, 0xff, 0xff, + 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x28, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0xa6, 0x31, 0x0, 0x0, 0x24, 0x8c, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2d, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xa4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x14, 0x7a, 0xcd, 0xef, 0xfe, + 0xec, 0x97, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+0399 "Ι" */ + 0x2a, 0xaa, 0xaa, 0xa8, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, + 0x3f, 0xff, 0xff, 0xfc, + + /* U+039A "Κ" */ + 0x5a, 0xaa, 0xaa, 0xa4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xaa, 0xaa, 0xaa, 0xaa, 0x90, 0x8, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xff, 0xe2, 0x0, 0x8f, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, + 0xff, 0xe2, 0x0, 0x8, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, 0xd2, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xff, 0xd1, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xff, 0xc1, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0x70, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf7, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x70, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, + 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x79, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, + 0xfd, 0xcf, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x11, + 0xef, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x10, 0x5, 0xff, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x10, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x10, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x8f, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0xff, 0x60, 0x8, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0x20, 0x8f, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xfd, + 0x0, + + /* U+039B "Λ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0x88, 0x88, 0x88, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xdf, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xf5, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0xa, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xb0, 0x5f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xf6, 0x1, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0x10, 0xb, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xb0, 0x0, 0x6f, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0x0, 0x0, 0xa, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x7, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xf1, + 0x0, 0x3f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, + 0x70, 0x9, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xfd, 0x0, 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xf4, 0x6f, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xff, 0xa0, + + /* U+039C "Μ" */ + 0x4a, 0xaa, 0xaa, 0xaa, 0xaa, 0xa2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xaa, 0xaa, 0xaa, + 0xaa, 0xa1, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xff, 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xf1, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0x7f, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf8, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xcf, 0xff, 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, + 0xdf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xfc, 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, + 0xff, 0xf5, 0x8f, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xf7, 0xaf, 0xff, 0xff, 0xf1, + 0x7f, 0xff, 0xff, 0xf5, 0x3f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xf1, 0xaf, 0xff, + 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, 0xd, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xc0, + 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, + 0x8, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0x60, 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, + 0xff, 0xf5, 0x2, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0x10, 0xaf, 0xff, 0xff, 0xf1, + 0x7f, 0xff, 0xff, 0xf5, 0x0, 0xdf, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xfb, 0x0, 0xaf, 0xff, + 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x7f, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xf5, 0x0, + 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, + 0x0, 0x2f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xf0, 0x0, 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, + 0xff, 0xf5, 0x0, 0xc, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xa0, 0x0, 0xaf, 0xff, 0xff, 0xf1, + 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x7, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0x50, 0x0, 0xaf, 0xff, + 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x1, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, + 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xe0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0x90, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0x30, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, + 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, + 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, + 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf4, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x40, 0x0, 0xdf, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, + 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0x90, 0x3, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xe0, 0x8, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xf3, 0xe, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xf8, 0x3f, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, + 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xfe, 0x8f, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, + 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, 0x7f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, + 0x7f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xf1, + + /* U+039D "Ν" */ + 0x1a, 0xaa, 0xaa, 0xaa, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xaa, 0xaa, 0xaa, 0x62, 0xff, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xf9, 0x2f, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0x92, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf9, 0x2f, 0xff, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0x92, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xf9, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x92, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf9, 0x2f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0x92, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf9, 0x2f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0x92, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xf9, 0x2f, 0xff, 0xff, 0xf9, 0xdf, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x92, + 0xff, 0xff, 0xff, 0x92, 0xff, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xf9, 0x2f, 0xff, 0xff, + 0xf9, 0x7, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0x92, 0xff, 0xff, 0xff, 0x90, 0xc, + 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf9, + 0x2f, 0xff, 0xff, 0xf9, 0x0, 0x2f, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0x92, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x7f, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xf9, 0x2f, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0x92, 0xff, 0xff, 0xff, 0x90, 0x0, 0x2, 0xff, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf9, 0x2f, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0x92, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xf9, 0x2f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x92, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf9, 0x2f, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0x92, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf9, 0x2f, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0x92, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xf9, 0x2f, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x92, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xf9, 0x2f, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0x92, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf9, + 0x2f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0x92, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xf9, 0x2f, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xff, 0xe1, 0x0, 0x2, 0xff, 0xff, 0xff, + 0x92, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0x2f, 0xff, 0xff, 0xf9, 0x2f, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0x50, 0x2, + 0xff, 0xff, 0xff, 0x92, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xff, 0xfe, 0x10, 0x2f, 0xff, 0xff, + 0xf9, 0x2f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xfb, 0x2, 0xff, 0xff, 0xff, 0x92, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xf6, + 0x2f, 0xff, 0xff, 0xf9, 0x2f, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xff, 0xff, 0xf4, 0xff, 0xff, + 0xff, 0x92, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xf9, 0x2f, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x92, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf9, 0x2f, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x92, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0x2f, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x92, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x2f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0x92, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xff, 0xff, 0xf9, 0x2f, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, + 0x92, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xf9, 0x2f, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xff, 0x90, + + /* U+039E "Ξ" */ + 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x20, 0x1, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x20, 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x20, 0x1, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x20, 0x1, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x20, 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x20, 0x0, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x20, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x30, 0x1f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf2, 0x1f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf2, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x1f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf2, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf2, + + /* U+039F "Ο" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x14, 0x8a, 0xce, 0xff, 0xfe, 0xec, 0x97, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x6c, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xa4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0x9f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3e, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb7, 0x42, + 0x0, 0x1, 0x35, 0x9d, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x61, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x29, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2b, 0xff, 0xff, 0xff, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xff, 0xc2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0xf7, 0x0, 0x2, 0xff, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xfc, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0x10, 0xb, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x40, + 0xe, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0x80, 0x1f, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xb0, 0x3f, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xd0, 0x4f, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xf0, + 0x6f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xf0, 0x7f, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xf1, 0x8f, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xf1, + 0x7f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0xf1, 0x7f, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xf0, 0x6f, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xf0, 0x3f, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xd0, + 0x1f, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xb0, 0xe, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xff, 0x80, 0xa, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xff, 0x50, 0x6, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0x10, + 0x2, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xc1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xff, 0xfe, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1a, 0xff, 0xff, 0xff, 0xff, + 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x28, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0xa6, 0x31, 0x0, 0x0, 0x24, 0x8c, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2d, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xa4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x14, 0x7a, 0xcd, 0xef, 0xfe, + 0xec, 0x97, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+03A0 "Π" */ + 0x3, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x11, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf7, 0x1f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x71, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x1f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x71, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf7, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x71, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xf7, 0x1f, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x71, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x1f, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0x71, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xf7, 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x71, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x1f, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x71, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0x71, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf7, 0x1f, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x71, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x1f, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x71, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xf7, 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x71, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xf7, 0x1f, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x71, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x1f, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0x71, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xf7, 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x71, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x1f, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x71, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0x71, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf7, 0x1f, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x71, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x1f, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x71, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xf7, 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x71, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xf7, 0x1f, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x71, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x1f, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0x71, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xf7, 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x71, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x1f, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x71, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0x71, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf7, 0x1f, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x71, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf7, 0x1f, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x70, 0x88, 0x88, 0x88, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x48, 0x88, 0x88, + 0x83, + + /* U+03A1 "Ρ" */ + 0x13, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x22, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0xa8, 0x41, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb4, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xb2, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x40, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x20, 0x0, 0x4f, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x12, + 0x47, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x4f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xcf, + 0xff, 0xff, 0xff, 0xf6, 0x0, 0x4f, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xfd, 0x0, 0x4f, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0x30, 0x4f, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0x80, 0x4f, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, + 0xc0, 0x4f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xf0, 0x4f, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xf0, 0x4f, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xf1, + 0x4f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0xf1, 0x4f, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xf1, 0x4f, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xf0, 0x4f, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xc0, 0x4f, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, + 0x90, 0x4f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0x40, 0x4f, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xfe, 0x0, 0x4f, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x4f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5d, 0xff, + 0xff, 0xff, 0xff, 0xe0, 0x0, 0x4f, 0xff, 0xff, + 0xfc, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x45, 0x69, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfb, 0x30, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xe9, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xec, + 0xb8, 0x62, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x28, 0x88, 0x88, 0x85, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A3 "Σ" */ + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x60, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x60, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x60, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x60, 0xaf, 0xff, 0xff, 0xff, 0x73, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x10, 0x3f, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xef, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0x63, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0xaf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + + /* U+03A4 "Τ" */ + 0x13, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x26, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf9, 0x6f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x96, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x6f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x96, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0x88, 0x88, 0x88, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+03A5 "Υ" */ + 0x48, 0x88, 0x88, 0x88, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x48, 0x88, 0x88, 0x88, + 0x42, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, + 0xf2, 0x6, 0xff, 0xff, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0xc, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0xe1, 0x0, + 0xcf, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0x90, + 0x6f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, + 0x4e, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+03A6 "Φ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0x22, 0x22, 0x22, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0x68, 0xbd, 0xee, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xed, 0xb9, 0x63, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0x9d, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0xa4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4c, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xed, 0xff, 0xff, 0xff, 0xfc, + 0xde, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb7, 0x40, 0x0, 0xf, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x36, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0x20, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x18, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0xc2, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xcf, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0x90, 0x0, + 0xd, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, + 0xff, 0x20, 0x5, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0xbf, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xe0, 0xf, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xff, 0x35, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xf7, 0x8f, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xab, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xfc, 0xcf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0xed, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfe, 0xef, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0xfe, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xfe, 0xdf, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xdb, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfb, + 0x9f, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0x96, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xf6, 0x2f, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0x20, + 0xdf, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xd0, 0x7, 0xff, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xf7, 0x0, 0x1f, 0xff, 0xff, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0x10, 0x0, + 0x8f, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, 0xc1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xcf, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x50, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x29, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd9, 0x51, 0x0, 0xf, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x37, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xed, 0xff, + 0xff, 0xff, 0xfd, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0x8d, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x81, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x58, 0xbc, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xec, 0xb8, 0x51, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A7 "Χ" */ + 0x0, 0x9, 0xaa, 0xaa, 0xaa, 0xa3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xaa, 0xaa, 0xaa, 0xa2, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xef, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x1e, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x7, 0xff, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xef, 0xff, 0xff, 0xff, 0x30, 0x3, 0xff, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xfd, 0x0, 0xdf, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xf7, 0x8f, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xf2, 0xdf, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0xf7, 0x3, 0xff, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xfc, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xff, 0x20, 0x0, 0xd, 0xff, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0xfe, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x2, 0xef, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0xf2, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xff, 0xc0, 0x4f, 0xff, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0xff, 0x80, + + /* U+03A8 "Ψ" */ + 0x4a, 0xaa, 0xaa, 0xa6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xaa, 0xaa, 0xaa, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8a, + 0xaa, 0xaa, 0xa2, 0x6f, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf3, 0x6f, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xf3, 0x6f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xf3, 0x6f, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf3, 0x6f, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xf3, 0x6f, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xf3, 0x6f, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf3, + 0x6f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xf3, 0x6f, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf3, 0x6f, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xf3, 0x6f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xf3, 0x6f, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf3, 0x6f, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xf3, 0x6f, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xf3, 0x6f, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf3, + 0x6f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0xf3, 0x5f, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xf2, 0x4f, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0xf1, 0x3f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xf0, 0x1f, 0xff, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xd0, 0xe, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xa0, 0xb, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xff, 0x70, 0x6, 0xff, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0x30, + 0x1, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xfd, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xe7, 0x10, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x2, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x85, 0x20, 0x9, 0xff, 0xff, + 0xff, 0x61, 0x23, 0x59, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xde, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5b, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0x94, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0x69, 0xbd, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0xca, 0x85, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03A9 "Ω" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x36, 0x9c, 0xdd, 0xee, 0xdc, 0xb8, 0x62, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x83, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3d, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x95, 0x21, 0x0, + 0x13, 0x6b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xc4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1c, 0xff, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xff, 0xfd, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x5, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0xe, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, + 0x50, 0x2, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x5f, 0xff, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xb0, 0x8, 0xff, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xfe, 0x0, 0xbf, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0xf0, 0xc, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xff, 0x10, 0xdf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0xf2, 0xe, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xff, 0x30, 0xef, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0xf3, 0xd, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xff, 0x30, 0xcf, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0xf2, 0xb, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x10, 0x9f, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf0, 0x7, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xfc, 0x0, + 0x4f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x90, + 0x0, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf5, + 0x0, 0xb, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0x10, 0x0, 0x6f, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xc0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xe1, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xef, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfc, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xfe, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1a, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x8f, 0xff, 0xff, + 0xff, 0xc3, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xff, 0xc3, 0x33, 0x33, 0x33, 0x33, 0x32, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd8, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, + + /* U+03AA "Ϊ" */ + 0x5, 0x55, 0x55, 0x54, 0x0, 0x0, 0x0, 0x35, + 0x55, 0x55, 0x51, 0xf, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf3, 0xf, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xf3, 0xf, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xf3, 0xf, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf3, 0xf, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xf3, 0xf, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xf3, 0xf, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xaa, 0xaa, 0xaa, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + + /* U+03AB "Ϋ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x35, + 0x55, 0x55, 0x50, 0x0, 0x0, 0x0, 0x55, 0x55, + 0x55, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xcc, 0xcc, + 0xcc, 0xcb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xcc, 0xcc, 0xcc, 0xc6, 0xe, 0xff, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xfd, 0x0, 0x4f, + 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x9f, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xfe, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x4f, 0xff, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xff, 0x20, 0xd, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xfa, 0x8, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xf6, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03AC "ά" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x11, 0x11, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0x7b, 0xdf, 0xff, 0xec, 0x95, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xdf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x2, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd3, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x7f, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0xcf, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0x76, 0x68, 0xbf, 0xff, + 0xff, 0xfe, 0x21, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x1, 0x9f, 0xff, 0xff, 0xc6, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x9, 0xff, 0xff, 0xff, 0xfd, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x20, 0x0, 0x1f, 0xff, + 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0xef, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x4, 0xff, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xf2, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xff, 0xe0, 0x0, 0xc, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xb0, 0x0, 0xf, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x1f, 0xff, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x30, 0x0, + 0xe, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0x60, 0x0, 0xb, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xff, 0x90, 0x0, 0x7, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xd0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xfb, 0x10, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xe4, 0x0, + 0x0, 0x0, 0x4, 0xdf, 0xff, 0xff, 0x86, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x2e, 0xff, 0xff, + 0xff, 0xff, 0xd8, 0x65, 0x68, 0xef, 0xff, 0xff, + 0xfe, 0x12, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf5, 0x0, 0xdf, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x3e, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x7f, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x1, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xcf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf9, 0x10, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0x7b, 0xdf, 0xff, 0xec, 0x95, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x22, 0x22, 0x22, + + /* U+03AD "έ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x11, 0x11, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x59, 0xcd, + 0xff, 0xfd, 0xb8, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x18, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe9, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd2, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xfe, + 0xb9, 0x9b, 0xef, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x4a, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xcf, 0xfe, 0x30, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7c, 0x10, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xd8, + 0x41, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xa7, + 0x76, 0x61, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xff, 0x81, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb4, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xcf, 0xf7, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xef, 0xff, 0xf9, 0x0, + 0x5, 0xff, 0xff, 0xff, 0xfd, 0x30, 0x0, 0x0, + 0x0, 0x3b, 0xff, 0xff, 0xff, 0xfc, 0x10, 0xc, + 0xff, 0xff, 0xff, 0xff, 0xc7, 0x55, 0x69, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x2e, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x2d, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x92, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x47, 0xbd, 0xef, 0xfe, 0xdb, + 0x84, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03AE "ή" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x11, 0x11, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x36, + 0x88, 0x98, 0x64, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x3, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x50, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xfe, 0x0, 0x2, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x30, 0x0, 0x0, + 0xff, 0xff, 0xfe, 0x0, 0x4e, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0xff, 0xff, 0xfe, 0x5, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, + 0xff, 0xff, 0xfe, 0x3f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0xff, 0xff, 0xfe, 0xef, 0xff, 0xff, 0xc7, 0x31, + 0x1, 0x26, 0xbf, 0xff, 0xff, 0xff, 0xfc, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd4, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, 0x20, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0x70, + 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xb0, + 0xff, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xd0, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf0, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf2, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf2, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x22, 0x22, 0x22, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + + /* U+03AF "ί" */ + 0x0, 0x0, 0x0, 0x11, 0x11, 0x11, 0x11, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x22, 0x22, 0x22, 0x10, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, + + /* U+03B0 "ΰ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xee, 0xee, 0xe5, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xa0, 0xc, 0xee, 0xee, 0xe6, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xf6, 0x0, 0x0, 0xaf, + 0xff, 0xfe, 0x10, 0xd, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xf6, 0x0, 0x2, 0xff, + 0xff, 0xf3, 0x0, 0xd, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xf6, 0x0, 0x9, 0xff, + 0xff, 0x80, 0x0, 0xd, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xf6, 0x0, 0x1f, 0xff, + 0xfc, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xf6, 0x0, 0x8f, 0xff, + 0xf2, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xf6, 0x1, 0xff, 0xff, + 0x50, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf9, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf9, + 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf9, + 0xf, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf8, + 0xf, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0xd, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf5, + 0xb, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf2, + 0x7, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xe0, + 0x4, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0x90, + 0x0, 0xef, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xff, 0xfc, 0x30, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x86, + 0x56, 0x9e, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2c, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe8, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x27, 0xad, 0xef, + 0xff, 0xdb, 0x84, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03B1 "α" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x7b, 0xdf, + 0xff, 0xec, 0x95, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x2, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd3, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x7f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf4, 0x0, 0xcf, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x76, + 0x68, 0xbf, 0xff, 0xff, 0xfe, 0x21, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x1, 0x9f, 0xff, 0xff, + 0xc6, 0xff, 0xff, 0xff, 0x60, 0x0, 0x9, 0xff, + 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0xef, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, 0xf6, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xff, 0xf2, 0x0, 0x8, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0xe0, 0x0, 0xc, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x1f, 0xff, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x3f, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x30, 0x0, 0xe, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0x60, 0x0, 0xb, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, + 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xfb, 0x10, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xfc, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xff, 0xe4, 0x0, 0x0, 0x0, 0x4, 0xdf, 0xff, + 0xff, 0x86, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x2e, 0xff, 0xff, 0xff, 0xff, 0xd8, 0x65, 0x68, + 0xef, 0xff, 0xff, 0xfe, 0x12, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, + 0xdf, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x3e, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x7f, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x1, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x5, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x10, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0x7b, 0xdf, 0xff, 0xec, 0x95, + 0x0, 0x0, 0x0, 0x0, 0x1, 0x22, 0x22, 0x22, + + /* U+03B2 "β" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x34, + 0x44, 0x31, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x16, 0xbe, + 0xff, 0xff, 0xff, 0xfe, 0xa5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x9f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xb1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x1d, 0xff, 0xff, 0xff, 0xfe, 0x94, + 0x10, 0x2, 0x5a, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xbf, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0x70, 0x0, + 0x3, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xe0, 0x0, 0x9, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf0, 0x0, 0xd, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0xef, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xc0, + 0x0, 0xe, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0xef, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, + 0xff, 0xff, 0x20, 0x0, 0xf, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xe1, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xcf, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x3, 0x7c, 0xff, 0xff, 0xff, 0xe3, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x8, 0xcc, 0xef, 0xff, 0xff, 0xff, 0xff, 0xa1, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xfa, + 0x30, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, + 0xd6, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe9, 0x30, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf8, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb2, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x1, 0x24, 0x7b, 0xff, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6e, 0xff, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1b, 0xff, 0xff, 0xff, 0xf4, 0x0, 0xf, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xe1, 0x0, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, + 0x90, 0xf, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0x10, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xf6, 0xf, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xb0, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0xf, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xf0, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, + 0xff, 0xff, 0x2f, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xf2, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0x1f, 0xff, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf0, 0xff, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xfe, + 0xf, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0x90, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf5, 0xf, 0xff, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xff, 0xff, 0x0, 0xff, 0xff, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0x80, 0xf, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0xf1, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xf6, + 0x0, 0xf, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, + 0xa3, 0x0, 0x0, 0x2, 0x6e, 0xff, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0xff, 0xff, 0xff, 0x87, 0xff, + 0xff, 0xff, 0xff, 0xdc, 0xce, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x10, 0x0, 0xf, 0xff, 0xff, 0xf8, + 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x10, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x80, 0x4, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x7e, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xa3, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x4, + 0x8b, 0xef, 0xff, 0xec, 0x96, 0x10, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03B3 "γ" */ + 0xe, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xfe, 0x0, 0x8f, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0x80, 0x2, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf2, 0x0, + 0xc, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xf1, 0x0, 0x1, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, 0x7f, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfc, 0x0, + 0xd, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xf2, 0x2, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0x80, 0x8f, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xfd, 0xe, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xf7, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xdf, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xd, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03B4 "δ" */ + 0x0, 0x0, 0x24, 0x44, 0x44, 0x44, 0x44, 0x44, + 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, + 0x40, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xfd, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, + 0xff, 0xfe, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xcf, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, + 0xc2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xfa, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2d, 0xff, 0xff, + 0xff, 0xfe, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x7b, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4c, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xc1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0xde, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x40, 0x0, 0x0, 0x49, + 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0xff, 0xb1, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x9f, 0xff, 0xff, 0xff, 0xe1, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0x80, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0x50, 0x0, 0xb, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xfd, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0xf4, 0x0, 0x7f, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0x90, 0xb, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xfe, + 0x0, 0xef, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xf1, 0x1f, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0x43, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf6, + 0x4f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0x75, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xf8, 0x6f, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x95, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xf8, 0x5f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0x83, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf6, 0x1f, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xff, 0x50, 0xef, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xf2, 0xb, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0x0, 0x6f, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0xb0, 0x1, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, + 0xff, 0xff, 0xf6, 0x0, 0xb, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0x10, 0x0, 0x4f, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1c, + 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x7, + 0xff, 0xff, 0xff, 0xff, 0xb2, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x86, 0x56, 0x7b, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x10, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xe5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7d, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0x7a, 0xde, 0xff, 0xfe, 0xca, + 0x62, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03B5 "ε" */ + 0x0, 0x0, 0x0, 0x0, 0x15, 0x9c, 0xdf, 0xff, + 0xdb, 0x84, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0x91, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, + 0x20, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xeb, 0x99, + 0xbe, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x4, + 0xaf, 0xff, 0xff, 0xf6, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x3c, + 0xff, 0xe3, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xc1, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xfd, 0x84, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2b, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xca, 0x77, 0x66, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xff, 0xf8, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0x40, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1c, 0xff, 0x70, 0x0, + 0xc, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5e, 0xff, 0xff, 0x90, 0x0, 0x5f, + 0xff, 0xff, 0xff, 0xd3, 0x0, 0x0, 0x0, 0x3, + 0xbf, 0xff, 0xff, 0xff, 0xc1, 0x0, 0xcf, 0xff, + 0xff, 0xff, 0xfc, 0x75, 0x56, 0x9d, 0xff, 0xff, + 0xff, 0xff, 0xfa, 0x0, 0x2, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x2, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xa1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe9, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0x7b, 0xde, 0xff, 0xed, 0xb8, 0x40, + 0x0, 0x0, 0x0, 0x0, + + /* U+03B6 "ζ" */ + 0x0, 0x0, 0x0, 0x24, 0x44, 0x44, 0x44, 0x44, + 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4e, + 0xff, 0xff, 0xfd, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xcf, 0xff, 0xff, + 0xe4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xef, 0xff, 0xff, 0xd2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xc1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xef, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, + 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x60, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xd6, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xca, + 0x86, 0x42, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xeb, 0x73, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x1d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x1a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x3, 0x9e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x45, 0x67, 0x77, 0x89, 0xcf, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1b, + 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xaf, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x49, 0xff, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xf9, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xfe, 0xc9, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03B7 "η" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x36, + 0x88, 0x98, 0x64, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x3, 0xaf, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x50, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xfe, 0x0, 0x2, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x30, 0x0, 0x0, + 0xff, 0xff, 0xfe, 0x0, 0x4e, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0xff, 0xff, 0xfe, 0x5, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, + 0xff, 0xff, 0xfe, 0x3f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x0, + 0xff, 0xff, 0xfe, 0xef, 0xff, 0xff, 0xc7, 0x31, + 0x1, 0x26, 0xbf, 0xff, 0xff, 0xff, 0xfc, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd4, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, 0x20, + 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, 0x70, + 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xb0, + 0xff, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xd0, + 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf0, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf2, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf2, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x22, 0x22, 0x22, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + + /* U+03B8 "θ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0x44, 0x43, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x49, + 0xdf, 0xff, 0xff, 0xff, 0xea, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x20, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xfe, + 0x83, 0x10, 0x13, 0x9e, 0xff, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0x10, + 0x0, 0x4, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xd0, 0x0, 0xf, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0x20, 0x3, 0xff, 0xff, + 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf6, 0x0, 0x7f, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xa0, + 0xb, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xfe, 0x0, 0xdf, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, + 0xff, 0xff, 0xf1, 0xf, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0x32, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf5, 0x4f, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x76, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xf9, 0x7f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0xa8, 0xff, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xfb, 0x9f, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xff, 0xca, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xaf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xda, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xda, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x9f, 0xff, 0xff, + 0xf4, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0xef, 0xff, 0xff, 0xd9, 0xff, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xfc, + 0x8f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xb7, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xfa, 0x5f, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0x94, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf7, 0x2f, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x50, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xf2, 0xd, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0x0, 0xaf, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xd0, 0x6, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xf9, 0x0, 0x2f, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0x50, 0x0, + 0xef, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, + 0x0, 0x8, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xe5, 0x0, + 0x0, 0x0, 0x3, 0xdf, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, + 0xfd, 0x86, 0x55, 0x8c, 0xff, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x18, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf9, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x48, + 0xbe, 0xff, 0xfe, 0xc9, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, + + /* U+03B9 "ι" */ + 0x2, 0x22, 0x22, 0x21, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, 0xf, 0xff, 0xff, 0xf7, + 0xf, 0xff, 0xff, 0xf7, + + /* U+03BA "κ" */ + 0x2, 0x22, 0x22, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0x22, 0x22, 0x22, 0x20, + 0x2, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0x2f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0xfa, + 0x0, 0x2, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1c, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, 0xe3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x3e, 0xff, 0xff, 0xff, 0xe2, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x3f, 0xff, 0xff, 0xff, 0xd1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xf5, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xc1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0x50, 0x4f, 0xff, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xf5, 0x5f, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xaf, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xff, 0x5d, + 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xfe, 0x30, + 0x2f, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x50, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x1, 0xdf, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0xfe, 0x10, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1d, 0xff, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0xf3, + 0x0, 0x2, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, + 0xe1, 0x0, 0x2f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xff, 0xd0, 0x2, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xb0, 0x2f, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xff, 0x80, + + /* U+03BB "λ" */ + 0x0, 0x0, 0x0, 0x0, 0x4, 0x88, 0x88, 0x88, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, + 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf6, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xef, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf4, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xfb, 0xc, 0xff, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0x50, 0x6f, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xe0, 0x0, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xf9, 0x0, 0xa, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x4f, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0x50, 0x0, 0xc, 0xff, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xfb, 0x0, 0x2, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf1, 0x0, + 0x8f, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0x70, 0xe, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xfd, 0x0, + + /* U+03BC "μ" */ + 0xbc, 0xcc, 0xcc, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4c, 0xcc, 0xcc, 0xc0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x50, 0x0, + 0x1, 0x6d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xed, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xac, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x78, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, 0xc, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x7f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc1, 0xc, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x4, 0xdf, 0xff, 0xff, + 0xff, 0xff, 0xe7, 0x0, 0xc, 0xff, 0xff, 0xf1, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x4, 0x9d, 0xff, + 0xfd, 0xa6, 0x0, 0x0, 0x4, 0x66, 0x66, 0x60, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03BD "ν" */ + 0xd, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xfe, 0x0, 0x7f, 0xff, 0xff, 0xf5, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0x90, 0x1, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf2, 0x0, + 0xb, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0xef, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0x90, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, + 0xff, 0xf4, 0x0, 0x3, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xa0, 0x0, 0x8f, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x0, + 0xe, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xf5, 0x4, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xa0, 0x9f, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xfe, 0xe, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xf7, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03BE "ξ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x58, 0xbd, + 0xef, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6c, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xfc, + 0xa7, 0x66, 0x55, 0x55, 0x54, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0xfd, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xaf, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf1, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xd5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xa, 0xff, 0xff, 0xff, 0xfe, 0x96, 0x31, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1d, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x1b, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x37, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6e, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xda, + 0x86, 0x62, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xff, 0xa5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, + 0xff, 0xf9, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xe3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xd1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf1, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, + 0xfc, 0x61, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x96, 0x41, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xc9, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3a, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x7b, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x36, + 0x8b, 0xef, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x16, 0xdf, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x12, 0x5b, 0xff, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xff, 0xfd, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xa3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9e, 0xdc, 0x85, 0x10, 0x0, 0x0, 0x0, + 0x0, + + /* U+03BF "ο" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x15, 0x9c, + 0xef, 0xff, 0xec, 0xa6, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xd8, 0x75, 0x68, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0xfa, 0x20, 0x0, + 0x0, 0x0, 0x18, 0xff, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xe3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xdf, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xff, 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0xdf, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xe0, 0x0, 0x3f, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0x40, 0x7, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf9, + 0x0, 0xbf, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0xe0, 0xe, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0x11, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf4, + 0x3f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0x64, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xf7, 0x5f, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0x86, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xf8, 0x6f, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0x85, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf7, 0x4f, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0x63, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xf5, 0x1f, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0x30, 0xef, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xf0, 0xb, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xfd, 0x0, 0x7f, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0x90, 0x3, 0xff, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf4, + 0x0, 0xd, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1e, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xfe, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1c, 0xff, 0xff, 0xff, 0xf1, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0xfe, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2d, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0x91, 0x0, 0x0, 0x0, 0x1, 0x7f, 0xff, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xff, 0xff, 0xfc, 0x86, 0x56, 0x7b, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe5, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4b, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x59, 0xce, 0xff, 0xfe, 0xca, 0x62, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+03C0 "π" */ + 0x13, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x16, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf7, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x76, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf7, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x76, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xb0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4f, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+03C1 "ρ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x23, + 0x45, 0x43, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x17, + 0xbf, 0xff, 0xff, 0xff, 0xff, 0xb7, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfa, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x10, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xfe, 0x94, 0x20, 0x12, 0x6b, 0xff, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x3c, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0xb, 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0xef, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xfd, 0x0, + 0x3, 0xff, 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x40, 0x7, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0x90, 0xa, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xff, 0xd0, 0xd, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xf0, + 0xf, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xf3, 0x1f, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xf5, 0x2f, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf6, 0x3f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf7, + 0x3f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xf7, 0x4f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xf7, 0x4f, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf6, 0x4f, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf5, + 0x4f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xf3, 0x4f, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xf0, 0x4f, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xd0, 0x4f, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0x90, + 0x4f, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xff, 0x40, 0x4f, 0xff, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xfe, 0x0, 0x4f, 0xff, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xf8, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0xf1, 0x0, + 0x4f, 0xff, 0xff, 0xff, 0xff, 0xe3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x1a, 0xff, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0x83, 0x10, 0x12, 0x5a, 0xff, + 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xf6, 0xef, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe3, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, 0x1c, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0x10, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x0, 0x6e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x50, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x5a, 0xef, 0xff, 0xff, + 0xff, 0xe9, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x1, + 0x34, 0x44, 0x31, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+03C2 "ς" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x34, 0x55, 0x43, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0x9c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdb, 0x73, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3a, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3c, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x2, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, 0xff, + 0xe9, 0x53, 0x10, 0x0, 0x13, 0x58, 0xbf, 0x90, + 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xff, 0xb3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x10, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, 0xd4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xbf, 0xff, 0xff, 0xfb, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0xfd, 0x10, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xff, 0xe5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xff, 0xff, 0xc4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd7, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfd, 0x94, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1b, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x92, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4d, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4a, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0x9d, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x15, 0x9e, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3b, 0xff, 0xff, 0xff, 0xf9, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0x10, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x43, 0x10, + 0x1, 0x48, 0xef, 0xff, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xd7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x29, 0xbd, 0xef, + 0xfe, 0xdb, 0x73, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03C3 "σ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x16, 0x9c, + 0xef, 0xfe, 0xdb, 0x73, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xcf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x3d, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0, 0x0, + 0x1, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xff, 0xff, 0xb8, 0x65, 0x68, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, 0xf8, + 0x10, 0x0, 0x0, 0x0, 0x17, 0xff, 0xff, 0xff, + 0xfe, 0x43, 0x33, 0x33, 0x33, 0x33, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0xd2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xcf, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xff, 0xc1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf3, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xf3, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xb0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xdf, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1d, + 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0xfc, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2d, 0xff, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x1, 0x8f, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x76, 0x56, 0x8c, 0xff, 0xff, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1c, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, + 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xc3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6d, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0x6a, 0xce, 0xff, + 0xfe, 0xc9, 0x51, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+03C4 "τ" */ + 0x13, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x15, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf8, 0x5f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x85, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x5f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x85, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf4, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0x40, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03C5 "υ" */ + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf9, + 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf9, + 0xf, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf8, + 0xf, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0xd, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf5, + 0xb, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf2, + 0x7, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xe0, + 0x3, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0x90, + 0x0, 0xef, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xff, 0xfc, 0x30, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x86, + 0x56, 0x9e, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2c, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe8, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x27, 0xad, 0xef, + 0xff, 0xdb, 0x84, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03C6 "φ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x6a, 0xcc, + 0x0, 0x0, 0x0, 0x4, 0x9c, 0xdd, 0xdc, 0xa7, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xaf, 0xff, 0xfb, 0x0, 0x0, + 0x2, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xcf, 0xff, 0xff, 0xff, 0xf0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0xfc, 0x88, 0xbf, 0xff, 0xff, + 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xff, 0xc4, 0x0, 0x0, 0xb, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x1, 0xbf, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, 0x10, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xf1, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, + 0xfe, 0x0, 0x3, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0x40, + 0x8, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x90, 0xc, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xcf, 0xff, 0xff, 0xd0, 0xf, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xf0, 0x2f, 0xff, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf3, + 0x4f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf5, 0x5f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6f, 0xff, 0xff, 0xf5, 0x5f, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xf6, 0x6f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf5, + 0x5f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf4, 0x4f, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xf2, 0x2f, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0xf0, 0xf, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xc0, + 0xc, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0x80, 0x9, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0xc, + 0xff, 0xff, 0xff, 0x30, 0x4, 0xff, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xfd, 0x0, 0x0, 0xef, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0x60, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xff, + 0xc1, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x3e, 0xff, 0xff, 0xff, 0xf2, 0x0, 0x0, + 0x0, 0x0, 0x1e, 0xff, 0xff, 0xff, 0xfe, 0x50, + 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x8, 0xff, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x61, 0xf, + 0xff, 0xff, 0xf7, 0x38, 0xef, 0xff, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1b, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x6e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x60, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0x8e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x60, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x49, 0xce, 0xff, 0xff, 0xff, 0xff, 0xb7, + 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + + /* U+03C7 "χ" */ + 0x1, 0xbc, 0xcc, 0xcc, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbc, + 0xcc, 0xcc, 0xc2, 0x0, 0x9, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xff, 0x30, 0x0, 0x0, 0x9f, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x6, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x1, + 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xf2, + 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x0, 0x1e, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xff, 0x10, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6f, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xfb, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x9, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, + 0xe0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4, 0xff, 0xff, 0xff, 0x70, 0x0, 0xaf, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xfe, + 0x0, 0x2f, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xf7, 0xa, 0xff, 0xff, 0xfe, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xe3, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xef, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xff, 0x7f, 0xff, + 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0x90, 0xdf, 0xff, 0xff, 0xc0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xf1, 0x5, 0xff, 0xff, + 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf8, + 0x0, 0xc, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0x10, 0x0, 0x4f, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0xcf, 0xff, 0xff, 0xf1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, + 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xef, 0xff, 0xff, 0xd0, 0x0, + 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, + 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x3, + 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0xe1, 0x0, + 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xff, 0x20, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x1, + 0xef, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0xc0, 0x0, 0x8f, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0xff, 0xff, 0x50, 0x2f, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, + 0xfd, 0x0, + + /* U+03C8 "ψ" */ + 0x7c, 0xcc, 0xcc, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xa, 0xcc, 0xcc, 0xc7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1, 0xcc, 0xcc, 0xcc, 0x39, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xf5, 0x9f, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0x59, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xf5, 0x9f, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, + 0x59, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf5, 0x9f, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xff, 0xff, 0xff, 0x59, 0xff, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2f, 0xff, 0xff, 0xf5, 0x9f, 0xff, 0xff, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, + 0xff, 0xff, 0x59, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, + 0xf5, 0x9f, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x59, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf5, 0x9f, 0xff, + 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0xff, 0xff, 0xff, 0x59, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, + 0xff, 0xff, 0xf5, 0x9f, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, + 0xff, 0x59, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, 0xff, 0xf5, + 0x9f, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x59, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xf5, 0x9f, 0xff, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, + 0xff, 0xff, 0xff, 0x49, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xf4, 0x9f, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, + 0x48, 0xff, 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xef, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf3, 0x8f, + 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xe, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xff, 0xff, 0xff, 0x37, 0xff, 0xff, + 0xff, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x5f, 0xff, 0xff, 0xf1, 0x5f, 0xff, 0xff, 0xf3, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x4, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, + 0xe0, 0x2f, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xfc, 0x0, + 0xef, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0x90, 0xa, 0xff, + 0xff, 0xff, 0x50, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xf5, 0x0, 0x5f, 0xff, 0xff, + 0xfe, 0x10, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, + 0xff, 0xff, 0x10, 0x0, 0xdf, 0xff, 0xff, 0xfd, + 0x10, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xff, + 0xa0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xfe, 0x30, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x9, 0xff, 0xff, 0xff, 0xff, 0xb4, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x16, + 0xdf, 0xff, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0xb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc9, 0x87, + 0xef, 0xff, 0xff, 0xc7, 0x8a, 0xcf, 0xff, 0xff, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4b, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xea, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x47, 0xac, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0xdc, 0x97, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, + 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, + 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xa0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xe, 0xff, 0xff, 0xfa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xef, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xfa, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xe, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, + 0xa0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xfa, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, + + /* U+03C9 "ω" */ + 0x0, 0x0, 0x6, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x4f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0x20, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xf0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0xef, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xfb, 0x0, 0x4, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x28, 0x88, 0x88, + 0x81, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xff, 0x10, 0x9, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7, 0xff, 0xff, 0xff, 0x50, 0xd, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x90, + 0x1f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0xd0, 0x4f, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xf0, 0x7f, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf3, 0x9f, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf5, + 0xbf, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xf7, 0xcf, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf8, 0xdf, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf9, 0xdf, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xfa, + 0xdf, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf9, 0xcf, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf9, 0xbf, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf8, 0xaf, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf7, + 0x8f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xf5, 0x5f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xf2, 0x2f, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf0, 0xe, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xc0, + 0x9, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x70, 0x3, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xff, 0x20, 0x0, 0xef, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xfd, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x2, + 0xef, 0xff, 0xf6, 0x9f, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0xe3, 0x0, 0x0, + 0x0, 0x4e, 0xff, 0xff, 0xd0, 0x1f, 0xff, 0xff, + 0xd2, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, + 0xa4, 0x11, 0x4a, 0xff, 0xff, 0xff, 0x40, 0x7, + 0xff, 0xff, 0xff, 0x93, 0x12, 0x5b, 0xff, 0xff, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xa0, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x1, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xef, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x7b, 0xef, 0xfe, 0xc9, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xad, 0xef, 0xfd, + 0xa6, 0x10, 0x0, 0x0, 0x0, 0x0, + + /* U+03CA "ϊ" */ + 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x8, 0xff, + 0xff, 0xff, 0x4f, 0xff, 0xff, 0xfd, 0x0, 0x0, + 0x0, 0x8f, 0xff, 0xff, 0xf4, 0xff, 0xff, 0xff, + 0xd0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, 0x4f, + 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x8f, 0xff, + 0xff, 0xf4, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x8, 0xff, 0xff, 0xff, 0x4f, 0xff, 0xff, 0xfd, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf4, 0xff, + 0xff, 0xff, 0xd0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x45, 0x66, 0x66, 0x64, 0x0, 0x0, 0x0, + 0x36, 0x66, 0x66, 0x61, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x22, + 0x22, 0x21, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x70, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, + + /* U+03CB "ϋ" */ + 0x0, 0x0, 0x0, 0x55, 0x55, 0x55, 0x50, 0x0, + 0x0, 0x2, 0x55, 0x55, 0x55, 0x20, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xe0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf9, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf9, + 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf9, + 0xf, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf8, + 0xf, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0xd, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf5, + 0xb, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf2, + 0x7, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xe0, + 0x4, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xa0, + 0x0, 0xef, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xff, 0xfb, 0x30, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x86, + 0x56, 0x9e, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2c, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe8, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x27, 0xad, 0xef, + 0xff, 0xdb, 0x84, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03CC "ό" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x9, 0xff, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xfe, 0x20, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, 0xff, + 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, + 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0xb0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xd1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x11, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0x59, 0xce, 0xff, 0xfe, + 0xca, 0x62, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x4b, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0x60, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, 0xff, 0xff, + 0xff, 0xfd, 0x87, 0x56, 0x8b, 0xff, 0xff, 0xff, + 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x9, 0xff, + 0xff, 0xff, 0xff, 0xa2, 0x0, 0x0, 0x0, 0x1, + 0x8f, 0xff, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, + 0x5, 0xff, 0xff, 0xff, 0xfe, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2d, 0xff, 0xff, 0xff, 0xf5, + 0x0, 0x0, 0x0, 0xef, 0xff, 0xff, 0xfe, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1d, 0xff, + 0xff, 0xff, 0xe0, 0x0, 0x0, 0x6f, 0xff, 0xff, + 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x1e, 0xff, 0xff, 0xff, 0x70, 0x0, 0xd, + 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xfe, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, + 0xff, 0xff, 0xf4, 0x0, 0x7f, 0xff, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0x90, 0xb, 0xff, + 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xfe, + 0x0, 0xef, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xf1, 0x1f, 0xff, 0xff, 0xfb, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x8, 0xff, 0xff, 0xff, 0x43, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf6, + 0x4f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0xff, + 0xff, 0xff, 0x75, 0xff, 0xff, 0xff, 0x50, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0xff, 0xf8, 0x6f, 0xff, 0xff, + 0xf4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x86, + 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xf8, 0x5f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0x74, 0xff, 0xff, 0xff, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x4f, 0xff, 0xff, 0xf6, 0x3f, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, + 0xff, 0x51, 0xff, 0xff, 0xff, 0xb0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x9f, 0xff, 0xff, 0xf3, 0xe, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xc, 0xff, 0xff, 0xff, 0x0, 0xbf, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, + 0xd0, 0x7, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xf9, 0x0, 0x3f, 0xff, 0xff, 0xfe, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0x40, 0x0, 0xdf, + 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xe0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0xf3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xef, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0xd, 0xff, 0xff, 0xff, + 0xe2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0xcf, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x4f, + 0xff, 0xff, 0xff, 0xe3, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2, 0xdf, 0xff, 0xff, 0xff, 0x60, 0x0, + 0x0, 0x0, 0x9f, 0xff, 0xff, 0xff, 0xf9, 0x10, + 0x0, 0x0, 0x0, 0x17, 0xff, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xc8, 0x65, 0x67, 0xbf, 0xff, 0xff, + 0xff, 0xff, 0xd1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xc1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3c, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x4, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xd6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x15, 0x9c, 0xef, + 0xff, 0xec, 0xa6, 0x20, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, + + /* U+03CD "ύ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, + 0xff, 0xff, 0xff, 0xf5, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, + 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xff, + 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x11, 0x11, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfa, + 0x1f, 0xff, 0xff, 0xf6, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0xf9, + 0xf, 0xff, 0xff, 0xf7, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf9, + 0xf, 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf8, + 0xf, 0xff, 0xff, 0xfa, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xf7, + 0xd, 0xff, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf5, + 0xb, 0xff, 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf2, + 0x7, 0xff, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xe0, + 0x3, 0xff, 0xff, 0xff, 0xd0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0x90, + 0x0, 0xef, 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2e, 0xff, 0xff, 0xff, 0x40, + 0x0, 0x7f, 0xff, 0xff, 0xff, 0x80, 0x0, 0x0, + 0x0, 0x0, 0x2, 0xef, 0xff, 0xff, 0xfc, 0x0, + 0x0, 0xd, 0xff, 0xff, 0xff, 0xfc, 0x30, 0x0, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x86, + 0x56, 0x9e, 0xff, 0xff, 0xff, 0xff, 0x90, 0x0, + 0x0, 0x0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2c, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe6, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5c, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe8, 0x10, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x27, 0xad, 0xef, + 0xff, 0xdb, 0x84, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* U+03CE "ώ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, + 0xff, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0xff, + 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4f, 0xff, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xbf, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xff, + 0xff, 0x90, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x2f, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0xaf, 0xff, 0xff, 0x30, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xf6, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x11, + 0x11, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x6, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0xe, 0xff, 0xff, 0xf7, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0xef, 0xff, 0xff, 0xa0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xd, 0xff, 0xff, 0xfb, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0x30, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0xd, 0xff, 0xff, 0xfd, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, + 0xff, 0xff, 0x90, 0x0, 0x0, 0x3f, 0xff, 0xff, + 0xf7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xbf, 0xff, 0xff, 0xf0, 0x0, 0x0, 0xaf, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf6, 0x0, + 0x0, 0xff, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, + 0xfb, 0x0, 0x4, 0xff, 0xff, 0xff, 0x80, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x26, 0x66, 0x66, + 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, + 0xff, 0xff, 0xff, 0x10, 0x9, 0xff, 0xff, 0xff, + 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xff, 0xff, 0xff, 0x50, 0xd, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x90, + 0x1f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef, 0xff, + 0xff, 0xd0, 0x4f, 0xff, 0xff, 0xf7, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xbf, 0xff, 0xff, 0xf0, 0x7f, 0xff, 0xff, 0xf4, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x8f, 0xff, 0xff, 0xf3, 0x9f, 0xff, + 0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf5, + 0xbf, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, + 0xff, 0xf7, 0xcf, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0xff, 0xf8, 0xdf, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xf, 0xff, 0xff, 0xf9, 0xdf, 0xff, + 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x5f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xff, 0xfa, + 0xdf, 0xff, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, 0xf2, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, + 0xff, 0xf9, 0xcf, 0xff, 0xff, 0xd0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xff, 0xff, + 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0xff, 0xff, 0xf9, 0xbf, 0xff, 0xff, 0xd0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0xff, 0xf8, 0xaf, 0xff, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x6f, 0xff, 0xff, 0xf3, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xf7, + 0x8f, 0xff, 0xff, 0xf2, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0xff, + 0xff, 0xf5, 0x5f, 0xff, 0xff, 0xf5, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x9f, 0xff, 0xff, + 0xf6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x8f, 0xff, 0xff, 0xf2, 0x2f, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbf, + 0xff, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xdf, 0xff, 0xff, 0xf0, 0xe, 0xff, + 0xff, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0xc0, + 0x9, 0xff, 0xff, 0xff, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x4, 0xff, 0xff, 0xff, 0xff, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0xff, 0xff, + 0xff, 0x70, 0x3, 0xff, 0xff, 0xff, 0xc0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0xa, 0xff, 0xff, 0xff, + 0xff, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, + 0xff, 0xff, 0xff, 0x20, 0x0, 0xef, 0xff, 0xff, + 0xf5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xff, + 0xfe, 0xff, 0xff, 0xe1, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x9f, 0xff, 0xff, 0xfb, 0x0, 0x0, 0x6f, + 0xff, 0xff, 0xff, 0x20, 0x0, 0x0, 0x0, 0x2, + 0xef, 0xff, 0xf6, 0x9f, 0xff, 0xfc, 0x0, 0x0, + 0x0, 0x0, 0x5, 0xff, 0xff, 0xff, 0xf4, 0x0, + 0x0, 0xc, 0xff, 0xff, 0xff, 0xe3, 0x0, 0x0, + 0x0, 0x4e, 0xff, 0xff, 0xd0, 0x2f, 0xff, 0xff, + 0xd2, 0x0, 0x0, 0x0, 0x6f, 0xff, 0xff, 0xff, + 0xb0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, + 0xa4, 0x11, 0x4a, 0xff, 0xff, 0xff, 0x40, 0x7, + 0xff, 0xff, 0xff, 0x93, 0x12, 0x5b, 0xff, 0xff, + 0xff, 0xff, 0x10, 0x0, 0x0, 0x0, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf4, 0x0, 0x0, 0x0, 0x0, + 0x9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xb0, 0x0, 0x0, 0x1d, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf9, 0x0, 0x0, 0x0, 0x1, 0xcf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe4, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xfd, 0x40, 0x0, 0x0, 0x0, + 0x0, 0x6, 0xef, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x2, 0x7b, 0xef, 0xfe, 0xc9, 0x40, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x5, 0xad, 0xef, 0xfd, + 0xa6, 0x10, 0x0, 0x0, 0x0, 0x0, + + /* U+03F4 "ϴ" */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xff, + 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xff, 0x30, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xaf, 0xff, 0xff, 0x70, 0x0, 0x0, 0x0, + 0xb, 0xee, 0xee, 0xe6, 0x0, 0x0, 0x2f, 0xff, + 0xff, 0xb0, 0xb, 0xee, 0xee, 0xe6, 0xcf, 0xff, + 0xff, 0x70, 0x0, 0x9, 0xff, 0xff, 0xe1, 0x0, + 0xcf, 0xff, 0xff, 0x7c, 0xff, 0xff, 0xf7, 0x0, + 0x1, 0xff, 0xff, 0xf4, 0x0, 0xc, 0xff, 0xff, + 0xf7, 0xcf, 0xff, 0xff, 0x70, 0x0, 0x8f, 0xff, + 0xf8, 0x0, 0x0, 0xcf, 0xff, 0xff, 0x7c, 0xff, + 0xff, 0xf7, 0x0, 0x1f, 0xff, 0xfc, 0x0, 0x0, + 0xc, 0xff, 0xff, 0xf7, 0xcf, 0xff, 0xff, 0x70, + 0x7, 0xff, 0xff, 0x20, 0x0, 0x0, 0xcf, 0xff, + 0xff, 0x7c, 0xff, 0xff, 0xf7, 0x0, 0xef, 0xff, + 0x60, 0x0, 0x0, 0xc, 0xff, 0xff, 0xf7 +}; + + +/*--------------------- + * GLYPH DESCRIPTION + *--------------------*/ + +static const lv_font_fmt_txt_glyph_dsc_t glyph_dsc[] = { + {.bitmap_index = 0, .adv_w = 0, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0} /* id = 0 reserved */, + {.bitmap_index = 0, .adv_w = 329, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 0, .adv_w = 330, .box_w = 9, .box_h = 53, .ofs_x = 6, .ofs_y = 0}, + {.bitmap_index = 239, .adv_w = 420, .box_w = 20, .box_h = 19, .ofs_x = 3, .ofs_y = 34}, + {.bitmap_index = 429, .adv_w = 658, .box_w = 41, .box_h = 55, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 1557, .adv_w = 658, .box_w = 36, .box_h = 65, .ofs_x = 2, .ofs_y = -8}, + {.bitmap_index = 2727, .adv_w = 1053, .box_w = 58, .box_h = 56, .ofs_x = 4, .ofs_y = -2}, + {.bitmap_index = 4351, .adv_w = 790, .box_w = 45, .box_h = 56, .ofs_x = 3, .ofs_y = -2}, + {.bitmap_index = 5611, .adv_w = 224, .box_w = 8, .box_h = 19, .ofs_x = 3, .ofs_y = 34}, + {.bitmap_index = 5687, .adv_w = 395, .box_w = 18, .box_h = 69, .ofs_x = 4, .ofs_y = -15}, + {.bitmap_index = 6308, .adv_w = 395, .box_w = 19, .box_h = 69, .ofs_x = 2, .ofs_y = -15}, + {.bitmap_index = 6964, .adv_w = 460, .box_w = 25, .box_h = 23, .ofs_x = 2, .ofs_y = 31}, + {.bitmap_index = 7252, .adv_w = 691, .box_w = 36, .box_h = 35, .ofs_x = 4, .ofs_y = 9}, + {.bitmap_index = 7882, .adv_w = 330, .box_w = 8, .box_h = 19, .ofs_x = 6, .ofs_y = -11}, + {.bitmap_index = 7958, .adv_w = 394, .box_w = 21, .box_h = 7, .ofs_x = 2, .ofs_y = 16}, + {.bitmap_index = 8032, .adv_w = 330, .box_w = 8, .box_h = 8, .ofs_x = 6, .ofs_y = 0}, + {.bitmap_index = 8064, .adv_w = 329, .box_w = 21, .box_h = 55, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 8642, .adv_w = 658, .box_w = 35, .box_h = 54, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 9587, .adv_w = 658, .box_w = 20, .box_h = 53, .ofs_x = 8, .ofs_y = 0}, + {.bitmap_index = 10117, .adv_w = 658, .box_w = 36, .box_h = 53, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 11071, .adv_w = 658, .box_w = 35, .box_h = 54, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 12016, .adv_w = 658, .box_w = 37, .box_h = 53, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 12997, .adv_w = 658, .box_w = 36, .box_h = 53, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 13951, .adv_w = 658, .box_w = 36, .box_h = 54, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 14923, .adv_w = 658, .box_w = 35, .box_h = 53, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 15851, .adv_w = 658, .box_w = 36, .box_h = 54, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 16823, .adv_w = 658, .box_w = 36, .box_h = 54, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 17795, .adv_w = 330, .box_w = 8, .box_h = 38, .ofs_x = 6, .ofs_y = 0}, + {.bitmap_index = 17947, .adv_w = 330, .box_w = 8, .box_h = 49, .ofs_x = 6, .ofs_y = -11}, + {.bitmap_index = 18143, .adv_w = 691, .box_w = 36, .box_h = 36, .ofs_x = 4, .ofs_y = 8}, + {.bitmap_index = 18791, .adv_w = 691, .box_w = 36, .box_h = 22, .ofs_x = 4, .ofs_y = 15}, + {.bitmap_index = 19187, .adv_w = 691, .box_w = 36, .box_h = 36, .ofs_x = 4, .ofs_y = 8}, + {.bitmap_index = 19835, .adv_w = 658, .box_w = 35, .box_h = 54, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 20780, .adv_w = 1202, .box_w = 69, .box_h = 69, .ofs_x = 4, .ofs_y = -15}, + {.bitmap_index = 23161, .adv_w = 790, .box_w = 51, .box_h = 53, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 24513, .adv_w = 790, .box_w = 41, .box_h = 53, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 25600, .adv_w = 855, .box_w = 48, .box_h = 54, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 26896, .adv_w = 855, .box_w = 45, .box_h = 53, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 28089, .adv_w = 790, .box_w = 41, .box_h = 53, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 29176, .adv_w = 725, .box_w = 37, .box_h = 53, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 30157, .adv_w = 921, .box_w = 50, .box_h = 54, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 31507, .adv_w = 855, .box_w = 43, .box_h = 53, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 32647, .adv_w = 330, .box_w = 8, .box_h = 53, .ofs_x = 6, .ofs_y = 0}, + {.bitmap_index = 32859, .adv_w = 592, .box_w = 31, .box_h = 54, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 33696, .adv_w = 790, .box_w = 45, .box_h = 53, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 34889, .adv_w = 658, .box_w = 34, .box_h = 53, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 35790, .adv_w = 986, .box_w = 52, .box_h = 53, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 37168, .adv_w = 855, .box_w = 43, .box_h = 53, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 38308, .adv_w = 921, .box_w = 52, .box_h = 54, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 39712, .adv_w = 790, .box_w = 42, .box_h = 54, .ofs_x = 5, .ofs_y = -1}, + {.bitmap_index = 40846, .adv_w = 921, .box_w = 53, .box_h = 58, .ofs_x = 3, .ofs_y = -5}, + {.bitmap_index = 42383, .adv_w = 855, .box_w = 48, .box_h = 53, .ofs_x = 5, .ofs_y = -1}, + {.bitmap_index = 43655, .adv_w = 790, .box_w = 43, .box_h = 55, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 44838, .adv_w = 725, .box_w = 43, .box_h = 54, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 45999, .adv_w = 855, .box_w = 43, .box_h = 54, .ofs_x = 5, .ofs_y = -1}, + {.bitmap_index = 47160, .adv_w = 790, .box_w = 49, .box_h = 53, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 48459, .adv_w = 1118, .box_w = 69, .box_h = 53, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 50288, .adv_w = 790, .box_w = 49, .box_h = 53, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 51587, .adv_w = 790, .box_w = 49, .box_h = 53, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 52886, .adv_w = 725, .box_w = 43, .box_h = 53, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 54026, .adv_w = 330, .box_w = 16, .box_h = 68, .ofs_x = 4, .ofs_y = -15}, + {.bitmap_index = 54570, .adv_w = 329, .box_w = 21, .box_h = 55, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 55148, .adv_w = 330, .box_w = 15, .box_h = 68, .ofs_x = 1, .ofs_y = -15}, + {.bitmap_index = 55658, .adv_w = 556, .box_w = 32, .box_h = 29, .ofs_x = 1, .ofs_y = 25}, + {.bitmap_index = 56122, .adv_w = 658, .box_w = 43, .box_h = 5, .ofs_x = -1, .ofs_y = -15}, + {.bitmap_index = 56230, .adv_w = 394, .box_w = 14, .box_h = 11, .ofs_x = 3, .ofs_y = 43}, + {.bitmap_index = 56307, .adv_w = 658, .box_w = 37, .box_h = 40, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 57047, .adv_w = 658, .box_w = 35, .box_h = 54, .ofs_x = 4, .ofs_y = -1}, + {.bitmap_index = 57992, .adv_w = 592, .box_w = 35, .box_h = 40, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 58692, .adv_w = 658, .box_w = 34, .box_h = 54, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 59610, .adv_w = 658, .box_w = 37, .box_h = 40, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 60350, .adv_w = 330, .box_w = 24, .box_h = 53, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 60986, .adv_w = 658, .box_w = 35, .box_h = 55, .ofs_x = 2, .ofs_y = -15}, + {.bitmap_index = 61949, .adv_w = 658, .box_w = 33, .box_h = 53, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 62824, .adv_w = 263, .box_w = 8, .box_h = 53, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 63036, .adv_w = 263, .box_w = 16, .box_h = 68, .ofs_x = -4, .ofs_y = -15}, + {.bitmap_index = 63580, .adv_w = 592, .box_w = 33, .box_h = 53, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 64455, .adv_w = 263, .box_w = 8, .box_h = 53, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 64667, .adv_w = 986, .box_w = 53, .box_h = 39, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 65701, .adv_w = 658, .box_w = 32, .box_h = 39, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 66325, .adv_w = 658, .box_w = 37, .box_h = 40, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 67065, .adv_w = 658, .box_w = 34, .box_h = 54, .ofs_x = 5, .ofs_y = -15}, + {.bitmap_index = 67983, .adv_w = 658, .box_w = 34, .box_h = 54, .ofs_x = 2, .ofs_y = -15}, + {.bitmap_index = 68901, .adv_w = 395, .box_w = 22, .box_h = 39, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 69330, .adv_w = 592, .box_w = 33, .box_h = 40, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 69990, .adv_w = 330, .box_w = 19, .box_h = 53, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 70494, .adv_w = 658, .box_w = 32, .box_h = 39, .ofs_x = 4, .ofs_y = -1}, + {.bitmap_index = 71118, .adv_w = 592, .box_w = 37, .box_h = 38, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 71821, .adv_w = 855, .box_w = 53, .box_h = 38, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 72828, .adv_w = 592, .box_w = 37, .box_h = 39, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 73550, .adv_w = 592, .box_w = 36, .box_h = 54, .ofs_x = 1, .ofs_y = -15}, + {.bitmap_index = 74522, .adv_w = 592, .box_w = 35, .box_h = 39, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 75205, .adv_w = 395, .box_w = 22, .box_h = 69, .ofs_x = 2, .ofs_y = -15}, + {.bitmap_index = 75964, .adv_w = 308, .box_w = 7, .box_h = 69, .ofs_x = 6, .ofs_y = -15}, + {.bitmap_index = 76206, .adv_w = 395, .box_w = 22, .box_h = 69, .ofs_x = 1, .ofs_y = -15}, + {.bitmap_index = 76965, .adv_w = 691, .box_w = 38, .box_h = 13, .ofs_x = 3, .ofs_y = 19}, + {.bitmap_index = 77212, .adv_w = 329, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 77212, .adv_w = 658, .box_w = 39, .box_h = 56, .ofs_x = 1, .ofs_y = -2}, + {.bitmap_index = 78304, .adv_w = 658, .box_w = 37, .box_h = 36, .ofs_x = 2, .ofs_y = 8}, + {.bitmap_index = 78970, .adv_w = 658, .box_w = 42, .box_h = 53, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 80083, .adv_w = 308, .box_w = 7, .box_h = 69, .ofs_x = 6, .ofs_y = -15}, + {.bitmap_index = 80325, .adv_w = 658, .box_w = 35, .box_h = 69, .ofs_x = 3, .ofs_y = -15}, + {.bitmap_index = 81533, .adv_w = 394, .box_w = 21, .box_h = 8, .ofs_x = 2, .ofs_y = 46}, + {.bitmap_index = 81617, .adv_w = 872, .box_w = 55, .box_h = 54, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 83102, .adv_w = 444, .box_w = 26, .box_h = 28, .ofs_x = 1, .ofs_y = 26}, + {.bitmap_index = 83466, .adv_w = 658, .box_w = 32, .box_h = 33, .ofs_x = 4, .ofs_y = 3}, + {.bitmap_index = 83994, .adv_w = 691, .box_w = 36, .box_h = 23, .ofs_x = 4, .ofs_y = 15}, + {.bitmap_index = 84408, .adv_w = 394, .box_w = 21, .box_h = 7, .ofs_x = 2, .ofs_y = 16}, + {.bitmap_index = 84482, .adv_w = 872, .box_w = 55, .box_h = 54, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 85967, .adv_w = 473, .box_w = 21, .box_h = 20, .ofs_x = 4, .ofs_y = 34}, + {.bitmap_index = 86177, .adv_w = 691, .box_w = 36, .box_h = 44, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 86969, .adv_w = 394, .box_w = 24, .box_h = 28, .ofs_x = 0, .ofs_y = 26}, + {.bitmap_index = 87305, .adv_w = 394, .box_w = 23, .box_h = 29, .ofs_x = 1, .ofs_y = 25}, + {.bitmap_index = 87639, .adv_w = 658, .box_w = 32, .box_h = 53, .ofs_x = 5, .ofs_y = -15}, + {.bitmap_index = 88487, .adv_w = 636, .box_w = 41, .box_h = 68, .ofs_x = -1, .ofs_y = -15}, + {.bitmap_index = 89881, .adv_w = 332, .box_w = 9, .box_h = 8, .ofs_x = 6, .ofs_y = 22}, + {.bitmap_index = 89917, .adv_w = 658, .box_w = 32, .box_h = 33, .ofs_x = 5, .ofs_y = 3}, + {.bitmap_index = 90445, .adv_w = 987, .box_w = 58, .box_h = 56, .ofs_x = 3, .ofs_y = -2}, + {.bitmap_index = 92069, .adv_w = 394, .box_w = 14, .box_h = 11, .ofs_x = 8, .ofs_y = 44}, + {.bitmap_index = 92146, .adv_w = 790, .box_w = 51, .box_h = 53, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 93498, .adv_w = 928, .box_w = 59, .box_h = 53, .ofs_x = -4, .ofs_y = 0}, + {.bitmap_index = 95062, .adv_w = 992, .box_w = 59, .box_h = 53, .ofs_x = -4, .ofs_y = 0}, + {.bitmap_index = 96626, .adv_w = 454, .box_w = 25, .box_h = 53, .ofs_x = -4, .ofs_y = 0}, + {.bitmap_index = 97289, .adv_w = 917, .box_w = 58, .box_h = 54, .ofs_x = -4, .ofs_y = -1}, + {.bitmap_index = 98855, .adv_w = 1013, .box_w = 67, .box_h = 54, .ofs_x = -4, .ofs_y = 0}, + {.bitmap_index = 100664, .adv_w = 891, .box_w = 57, .box_h = 54, .ofs_x = -4, .ofs_y = 0}, + {.bitmap_index = 102203, .adv_w = 263, .box_w = 27, .box_h = 54, .ofs_x = -5, .ofs_y = 0}, + {.bitmap_index = 102932, .adv_w = 790, .box_w = 51, .box_h = 53, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 104284, .adv_w = 790, .box_w = 41, .box_h = 53, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 105371, .adv_w = 652, .box_w = 35, .box_h = 54, .ofs_x = 5, .ofs_y = -1}, + {.bitmap_index = 106316, .adv_w = 791, .box_w = 51, .box_h = 53, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 107668, .adv_w = 790, .box_w = 41, .box_h = 53, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 108755, .adv_w = 725, .box_w = 43, .box_h = 53, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 109895, .adv_w = 855, .box_w = 43, .box_h = 53, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 111035, .adv_w = 921, .box_w = 52, .box_h = 54, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 112439, .adv_w = 330, .box_w = 8, .box_h = 53, .ofs_x = 6, .ofs_y = 0}, + {.bitmap_index = 112651, .adv_w = 790, .box_w = 45, .box_h = 53, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 113844, .adv_w = 791, .box_w = 49, .box_h = 53, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 115143, .adv_w = 986, .box_w = 52, .box_h = 53, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 116521, .adv_w = 855, .box_w = 43, .box_h = 53, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 117661, .adv_w = 769, .box_w = 42, .box_h = 53, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 118774, .adv_w = 921, .box_w = 52, .box_h = 54, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 120178, .adv_w = 855, .box_w = 43, .box_h = 54, .ofs_x = 5, .ofs_y = -1}, + {.bitmap_index = 121339, .adv_w = 790, .box_w = 42, .box_h = 54, .ofs_x = 5, .ofs_y = -1}, + {.bitmap_index = 122473, .adv_w = 732, .box_w = 38, .box_h = 53, .ofs_x = 5, .ofs_y = 0}, + {.bitmap_index = 123480, .adv_w = 725, .box_w = 43, .box_h = 54, .ofs_x = 1, .ofs_y = -1}, + {.bitmap_index = 124641, .adv_w = 790, .box_w = 49, .box_h = 53, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 125940, .adv_w = 945, .box_w = 53, .box_h = 57, .ofs_x = 3, .ofs_y = -2}, + {.bitmap_index = 127451, .adv_w = 790, .box_w = 49, .box_h = 53, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 128750, .adv_w = 989, .box_w = 54, .box_h = 53, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 130181, .adv_w = 885, .box_w = 49, .box_h = 54, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 131504, .adv_w = 330, .box_w = 22, .box_h = 64, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 132208, .adv_w = 790, .box_w = 49, .box_h = 64, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 133776, .adv_w = 685, .box_w = 38, .box_h = 55, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 134821, .adv_w = 528, .box_w = 29, .box_h = 55, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 135619, .adv_w = 658, .box_w = 32, .box_h = 69, .ofs_x = 5, .ofs_y = -15}, + {.bitmap_index = 136723, .adv_w = 263, .box_w = 15, .box_h = 55, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 137136, .adv_w = 648, .box_w = 32, .box_h = 55, .ofs_x = 4, .ofs_y = -1}, + {.bitmap_index = 138016, .adv_w = 685, .box_w = 38, .box_h = 40, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 138776, .adv_w = 681, .box_w = 35, .box_h = 69, .ofs_x = 5, .ofs_y = -15}, + {.bitmap_index = 139984, .adv_w = 592, .box_w = 37, .box_h = 53, .ofs_x = 0, .ofs_y = -15}, + {.bitmap_index = 140965, .adv_w = 659, .box_w = 37, .box_h = 54, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 141964, .adv_w = 528, .box_w = 29, .box_h = 40, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 142544, .adv_w = 522, .box_w = 31, .box_h = 69, .ofs_x = 2, .ofs_y = -16}, + {.bitmap_index = 143614, .adv_w = 658, .box_w = 32, .box_h = 54, .ofs_x = 5, .ofs_y = -15}, + {.bitmap_index = 144478, .adv_w = 658, .box_w = 35, .box_h = 55, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 145441, .adv_w = 263, .box_w = 8, .box_h = 39, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 145597, .adv_w = 590, .box_w = 33, .box_h = 39, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 146241, .adv_w = 592, .box_w = 37, .box_h = 53, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 147222, .adv_w = 658, .box_w = 32, .box_h = 53, .ofs_x = 5, .ofs_y = -15}, + {.bitmap_index = 148070, .adv_w = 592, .box_w = 37, .box_h = 38, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 148773, .adv_w = 530, .box_w = 29, .box_h = 69, .ofs_x = 3, .ofs_y = -15}, + {.bitmap_index = 149774, .adv_w = 658, .box_w = 37, .box_h = 40, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 150514, .adv_w = 817, .box_w = 49, .box_h = 39, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 151470, .adv_w = 674, .box_w = 36, .box_h = 54, .ofs_x = 4, .ofs_y = -15}, + {.bitmap_index = 152442, .adv_w = 571, .box_w = 32, .box_h = 55, .ofs_x = 3, .ofs_y = -15}, + {.bitmap_index = 153322, .adv_w = 731, .box_w = 43, .box_h = 40, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 154182, .adv_w = 468, .box_w = 27, .box_h = 39, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 154709, .adv_w = 648, .box_w = 32, .box_h = 39, .ofs_x = 4, .ofs_y = -1}, + {.bitmap_index = 155333, .adv_w = 768, .box_w = 44, .box_h = 54, .ofs_x = 2, .ofs_y = -15}, + {.bitmap_index = 156521, .adv_w = 621, .box_w = 39, .box_h = 53, .ofs_x = 0, .ofs_y = -15}, + {.bitmap_index = 157555, .adv_w = 844, .box_w = 45, .box_h = 53, .ofs_x = 4, .ofs_y = -15}, + {.bitmap_index = 158748, .adv_w = 924, .box_w = 52, .box_h = 39, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 159762, .adv_w = 263, .box_w = 21, .box_h = 53, .ofs_x = -2, .ofs_y = 0}, + {.bitmap_index = 160319, .adv_w = 648, .box_w = 32, .box_h = 54, .ofs_x = 4, .ofs_y = -1}, + {.bitmap_index = 161183, .adv_w = 658, .box_w = 37, .box_h = 55, .ofs_x = 2, .ofs_y = -1}, + {.bitmap_index = 162201, .adv_w = 648, .box_w = 32, .box_h = 55, .ofs_x = 4, .ofs_y = -1}, + {.bitmap_index = 163081, .adv_w = 924, .box_w = 52, .box_h = 55, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 164511, .adv_w = 394, .box_w = 27, .box_h = 10, .ofs_x = -1, .ofs_y = 44} +}; + +/*--------------------- + * CHARACTER MAPPING + *--------------------*/ + +static const uint8_t glyph_id_ofs_list_1[] = { + 0, 0, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 0, + 13, 14, 15, 16, 0, 17, 18, 19, + 0, 0, 0, 20, 0, 21 +}; + +static const uint8_t glyph_id_ofs_list_2[] = { + 0, 0, 1, 0, 2, 3, 4, 0, + 5 +}; + +/*Collect the unicode lists and glyph_id offsets*/ +static const lv_font_fmt_txt_cmap_t cmaps[] = +{ + { + .range_start = 32, .range_length = 95, .glyph_id_start = 1, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 160, .range_length = 30, .glyph_id_start = 96, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_1, .list_length = 30, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 900, .range_length = 9, .glyph_id_start = 118, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_2, .list_length = 9, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 910, .range_length = 20, .glyph_id_start = 124, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 931, .range_length = 44, .glyph_id_start = 144, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 1012, .range_length = 1, .glyph_id_start = 188, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + } +}; + + + +/*-------------------- + * ALL CUSTOM DATA + *--------------------*/ + +#if LVGL_VERSION_MAJOR == 8 +/*Store all the custom data of the font*/ +static lv_font_fmt_txt_glyph_cache_t cache; +#endif + +#if LVGL_VERSION_MAJOR >= 8 +static const lv_font_fmt_txt_dsc_t font_dsc = { +#else +static lv_font_fmt_txt_dsc_t font_dsc = { +#endif + .glyph_bitmap = glyph_bitmap, + .glyph_dsc = glyph_dsc, + .cmaps = cmaps, + .kern_dsc = NULL, + .kern_scale = 0, + .cmap_num = 6, + .bpp = 4, + .kern_classes = 0, + .bitmap_format = 0, +#if LVGL_VERSION_MAJOR == 8 + .cache = &cache +#endif + +}; + +extern const lv_font_t lv_font_montserrat_48; + + +/*----------------- + * PUBLIC FONT + *----------------*/ + +/*Initialize a public general font descriptor*/ +#if LVGL_VERSION_MAJOR >= 8 +const lv_font_t lv_font_arial_74 = { +#else +lv_font_t lv_font_arial_74 = { +#endif + .get_glyph_dsc = lv_font_get_glyph_dsc_fmt_txt, /*Function pointer to get glyph's data*/ + .get_glyph_bitmap = lv_font_get_bitmap_fmt_txt, /*Function pointer to get glyph's bitmap*/ + .line_height = 80, /*The maximum line height required by the font*/ + .base_line = 16, /*Baseline measured from the bottom of the line*/ +#if !(LVGL_VERSION_MAJOR == 6 && LVGL_VERSION_MINOR == 0) + .subpx = LV_FONT_SUBPX_NONE, +#endif +#if LV_VERSION_CHECK(7, 4, 0) || LVGL_VERSION_MAJOR >= 8 + .underline_position = -8, + .underline_thickness = 5, +#endif + //.static_bitmap = 0, + .dsc = &font_dsc, /*The custom font data. Will be accessed by `get_glyph_bitmap/dsc` */ +#if LV_VERSION_CHECK(8, 2, 0) || LVGL_VERSION_MAJOR >= 9 + .fallback = &lv_font_montserrat_48, +#endif + .user_data = NULL, +}; + + + +#endif /*#if LV_FONT_ARIAL_74*/ diff --git a/src/fonts/lv_font_arial_8.c b/src/fonts/lv_font_arial_8.c new file mode 100644 index 0000000000..334decad80 --- /dev/null +++ b/src/fonts/lv_font_arial_8.c @@ -0,0 +1,1059 @@ +/******************************************************************************* + * Size: 8 px + * Bpp: 4 + * Opts: --bpp 4 --size 8 --no-compress --stride 1 --align 1 --font Arial Greek Regular.ttf --range 32-127,160-255,880-1023 --format lvgl -o lv_font_arial_8.c + ******************************************************************************/ + +#ifdef __has_include + #if __has_include("lvgl.h") + #ifndef LV_LVGL_H_INCLUDE_SIMPLE + #define LV_LVGL_H_INCLUDE_SIMPLE + #endif + #endif +#endif + +#ifdef LV_LVGL_H_INCLUDE_SIMPLE + #include "lvgl.h" +#else + #include "lvgl/lvgl.h" +#endif + + + +#ifndef LV_FONT_ARIAL_8 +#define LV_FONT_ARIAL_8 1 +#endif + +#if LV_FONT_ARIAL_8 + +/*----------------- + * BITMAPS + *----------------*/ + +/*Store the image of the glyphs*/ +static LV_ATTRIBUTE_LARGE_CONST const uint8_t glyph_bitmap[] = { + /* U+0020 " " */ + + /* U+0021 "!" */ + 0x58, 0x48, 0x37, 0x26, 0x36, + + /* U+0022 "\"" */ + 0x97, 0x77, 0x45, + + /* U+0023 "#" */ + 0x8, 0x9, 0x7, 0xc9, 0xc3, 0x9, 0x26, 0x9, + 0xbb, 0xa3, 0x72, 0x90, 0x0, + + /* U+0024 "$" */ + 0x18, 0xc3, 0x8, 0x46, 0x80, 0x5a, 0x70, 0x0, + 0x2b, 0xa0, 0x61, 0x6b, 0x3, 0xac, 0x80, 0x0, + 0x30, 0x0, + + /* U+0025 "%" */ + 0x58, 0x90, 0x62, 0x3, 0x76, 0x26, 0x0, 0x0, + 0x8, 0x58, 0x20, 0x5, 0x3a, 0x9, 0x1, 0x80, + 0x78, 0x50, + + /* U+0026 "&" */ + 0x9, 0x98, 0x0, 0xa, 0x39, 0x0, 0x2a, 0xc2, + 0x30, 0x93, 0x1d, 0x70, 0x3b, 0x98, 0xb0, 0x0, + 0x0, 0x0, + + /* U+0027 "'" */ + 0xa2, 0x71, + + /* U+0028 "(" */ + 0x7, 0x12, 0x80, 0x74, 0x7, 0x40, 0x28, 0x0, + 0x71, + + /* U+0029 ")" */ + 0x53, 0x0, 0xa0, 0x9, 0x10, 0x91, 0xa, 0x5, + 0x30, + + /* U+002A "*" */ + 0x39, 0x33, 0xc5, 0x0, 0x10, + + /* U+002B "+" */ + 0x0, 0x60, 0x0, 0xa, 0x0, 0x5a, 0xea, 0x20, + 0xa, 0x0, + + /* U+002C "," */ + 0x36, 0x14, 0x0, + + /* U+002D "-" */ + 0x7a, 0x40, + + /* U+002E "." */ + 0x36, + + /* U+002F "/" */ + 0x7, 0x10, 0x80, 0x26, 0x7, 0x10, 0x90, 0x0, + + /* U+0030 "0" */ + 0x1a, 0x96, 0x8, 0x30, 0xb0, 0xa1, 0xa, 0x8, + 0x30, 0xb0, 0x1a, 0x96, 0x0, + + /* U+0031 "1" */ + 0x1, 0xd1, 0x8c, 0x0, 0xb0, 0xb, 0x0, 0xb0, + + /* U+0032 "2" */ + 0x3a, 0x98, 0x4, 0x10, 0xb0, 0x0, 0x66, 0x0, + 0x94, 0x0, 0x9c, 0xaa, 0x0, + + /* U+0033 "3" */ + 0x2a, 0x96, 0x3, 0x10, 0xb0, 0x1, 0xb7, 0x3, + 0x10, 0xb0, 0x3a, 0x98, 0x0, + + /* U+0034 "4" */ + 0x0, 0xa5, 0x0, 0x79, 0x50, 0x45, 0x65, 0xa, + 0x9c, 0xb0, 0x0, 0x65, 0x0, + + /* U+0035 "5" */ + 0x1d, 0xa8, 0x5, 0xba, 0x50, 0x21, 0xb, 0x5, + 0x20, 0xa0, 0x3a, 0x96, 0x0, + + /* U+0036 "6" */ + 0x19, 0x88, 0x8, 0x89, 0x50, 0xa4, 0xb, 0x8, + 0x30, 0xa0, 0x1a, 0x97, 0x0, + + /* U+0037 "7" */ + 0x6a, 0xae, 0x0, 0x7, 0x40, 0x1, 0xa0, 0x0, + 0x74, 0x0, 0xb, 0x0, 0x0, + + /* U+0038 "8" */ + 0x29, 0x88, 0x5, 0xda, 0x70, 0x32, 0xb, 0x9, + 0x20, 0xa0, 0x3a, 0x97, 0x0, + + /* U+0039 "9" */ + 0x3a, 0x96, 0x9, 0x20, 0xb0, 0x2a, 0x8b, 0x14, + 0x10, 0xb0, 0x2a, 0x95, 0x0, + + /* U+003A ":" */ + 0x36, 0x0, 0x0, 0x36, + + /* U+003B ";" */ + 0x36, 0x0, 0x0, 0x36, 0x14, 0x0, + + /* U+003C "<" */ + 0x0, 0x3, 0x10, 0x6a, 0x70, 0x6c, 0x20, 0x0, + 0x17, 0xa1, 0x0, 0x0, 0x0, + + /* U+003D "=" */ + 0x59, 0x99, 0x25, 0xaa, 0xa2, + + /* U+003E ">" */ + 0x31, 0x0, 0x2, 0x89, 0x40, 0x0, 0x5d, 0x25, + 0xa5, 0x0, 0x0, 0x0, 0x0, + + /* U+003F "?" */ + 0x3a, 0x98, 0x4, 0x10, 0xb0, 0x0, 0x85, 0x0, + 0x16, 0x0, 0x2, 0x70, 0x0, + + /* U+0040 "@" */ + 0x1, 0x88, 0x89, 0x50, 0x9, 0x4a, 0x9b, 0x64, + 0x62, 0xb0, 0x2a, 0x9, 0x81, 0xb0, 0x56, 0x46, + 0x28, 0x99, 0xab, 0x81, 0x3, 0x98, 0x88, 0x83, + + /* U+0041 "A" */ + 0x1, 0xe3, 0x0, 0x7, 0x6b, 0x0, 0xc, 0xa, + 0x30, 0x5d, 0x9b, 0xa0, 0xb1, 0x0, 0xc2, + + /* U+0042 "B" */ + 0x6c, 0xab, 0x46, 0x50, 0x28, 0x6c, 0xad, 0x46, + 0x50, 0xc, 0x6c, 0xaa, 0x70, + + /* U+0043 "C" */ + 0x8, 0xaa, 0x90, 0x57, 0x0, 0x52, 0x83, 0x0, + 0x0, 0x57, 0x0, 0x63, 0x8, 0x9a, 0x90, + + /* U+0044 "D" */ + 0x6c, 0xaa, 0x60, 0x66, 0x0, 0xa2, 0x66, 0x0, + 0x75, 0x66, 0x0, 0xa2, 0x6c, 0xaa, 0x70, + + /* U+0045 "E" */ + 0x5c, 0xaa, 0x85, 0x60, 0x0, 0x5c, 0xaa, 0x55, + 0x60, 0x0, 0x5c, 0xaa, 0x90, + + /* U+0046 "F" */ + 0x5c, 0xaa, 0x55, 0x60, 0x0, 0x5c, 0xaa, 0x5, + 0x60, 0x0, 0x56, 0x0, 0x0, + + /* U+0047 "G" */ + 0x7, 0xa9, 0xa2, 0x58, 0x0, 0x13, 0x83, 0x7, + 0xa9, 0x58, 0x0, 0xb, 0x7, 0xaa, 0xa4, + + /* U+0048 "H" */ + 0x56, 0x0, 0xa2, 0x56, 0x0, 0xa2, 0x5c, 0xaa, + 0xd2, 0x56, 0x0, 0xa2, 0x56, 0x0, 0xa2, + + /* U+0049 "I" */ + 0x48, 0x48, 0x48, 0x48, 0x48, + + /* U+004A "J" */ + 0x0, 0x66, 0x0, 0x66, 0x0, 0x66, 0x60, 0x65, + 0x6b, 0xb1, + + /* U+004B "K" */ + 0x65, 0x6, 0x90, 0x65, 0x87, 0x0, 0x6d, 0xb3, + 0x0, 0x66, 0xc, 0x20, 0x65, 0x2, 0xc1, + + /* U+004C "L" */ + 0x65, 0x0, 0x6, 0x50, 0x0, 0x65, 0x0, 0x6, + 0x50, 0x0, 0x6c, 0xaa, 0x10, + + /* U+004D "M" */ + 0x6e, 0x0, 0x2f, 0x16, 0xb5, 0x8, 0xb1, 0x65, + 0xa0, 0x9a, 0x16, 0x59, 0x64, 0xa1, 0x65, 0x3d, + 0xa, 0x10, + + /* U+004E "N" */ + 0x5c, 0x0, 0x92, 0x5a, 0x80, 0x92, 0x55, 0x85, + 0x92, 0x55, 0xb, 0xb2, 0x55, 0x1, 0xe2, + + /* U+004F "O" */ + 0x8, 0xa9, 0x90, 0x57, 0x0, 0x39, 0x93, 0x0, + 0xc, 0x67, 0x0, 0x39, 0x8, 0xa9, 0x90, + + /* U+0050 "P" */ + 0x6c, 0xaa, 0x86, 0x60, 0xd, 0x6c, 0x9a, 0x56, + 0x60, 0x0, 0x66, 0x0, 0x0, + + /* U+0051 "Q" */ + 0x8, 0xaa, 0xa1, 0x57, 0x0, 0x3a, 0x93, 0x0, + 0xc, 0x57, 0x4, 0x49, 0x8, 0xac, 0xc6, 0x0, + 0x0, 0x2, + + /* U+0052 "R" */ + 0x5c, 0x99, 0xa0, 0x56, 0x0, 0xa2, 0x5c, 0xac, + 0x70, 0x56, 0x6, 0x80, 0x56, 0x0, 0xa5, + + /* U+0053 "S" */ + 0x1a, 0x9a, 0x45, 0x70, 0x5, 0x5, 0x99, 0x36, + 0x20, 0xc, 0x2b, 0xaa, 0x60, + + /* U+0054 "T" */ + 0x8a, 0xea, 0x70, 0xc, 0x0, 0x0, 0xc0, 0x0, + 0xc, 0x0, 0x0, 0xc0, 0x0, + + /* U+0055 "U" */ + 0x56, 0x0, 0x92, 0x56, 0x0, 0x92, 0x56, 0x0, + 0x92, 0x48, 0x0, 0xb1, 0xa, 0xaa, 0x70, + + /* U+0056 "V" */ + 0xb1, 0x0, 0xa1, 0x47, 0x2, 0x90, 0xb, 0x8, + 0x20, 0x6, 0x5a, 0x0, 0x0, 0xd4, 0x0, + + /* U+0057 "W" */ + 0xb0, 0xc, 0x60, 0x74, 0x74, 0x28, 0xa0, 0xb0, + 0x28, 0x72, 0xa1, 0xa0, 0xa, 0xa0, 0x59, 0x50, + 0x8, 0x80, 0xe, 0x0, + + /* U+0058 "X" */ + 0x49, 0x2, 0xa0, 0x7, 0x7b, 0x0, 0x0, 0xe5, + 0x0, 0xa, 0x4b, 0x20, 0x85, 0x2, 0xb0, + + /* U+0059 "Y" */ + 0x95, 0x1, 0xb0, 0xb, 0x2a, 0x20, 0x1, 0xd4, + 0x0, 0x0, 0xc0, 0x0, 0x0, 0xc0, 0x0, + + /* U+005A "Z" */ + 0x5a, 0xad, 0x80, 0x3, 0xa0, 0x3, 0xb0, 0x2, + 0xb0, 0x0, 0xcb, 0xaa, 0x60, + + /* U+005B "[" */ + 0x7a, 0x7, 0x30, 0x73, 0x7, 0x30, 0x73, 0x7, + 0xa0, + + /* U+005C "\\" */ + 0x80, 0x7, 0x10, 0x26, 0x0, 0x80, 0x7, 0x10, + + /* U+005D "]" */ + 0x7b, 0xb, 0xb, 0xb, 0xb, 0x7b, + + /* U+005E "^" */ + 0x9, 0x60, 0x18, 0xa0, 0x82, 0x55, + + /* U+005F "_" */ + 0x7, 0x77, 0x73, + + /* U+0060 "`" */ + 0x37, 0x1, + + /* U+0061 "a" */ + 0x3a, 0x99, 0x2, 0x35, 0xd0, 0x87, 0x2c, 0x6, + 0xa9, 0xd0, + + /* U+0062 "b" */ + 0x74, 0x0, 0x7, 0xa9, 0x70, 0x74, 0xa, 0x17, + 0x30, 0xa0, 0x7a, 0x77, 0x0, + + /* U+0063 "c" */ + 0x2a, 0x96, 0x91, 0x3, 0x91, 0x5, 0x2a, 0x96, + + /* U+0064 "d" */ + 0x0, 0xb, 0x2a, 0x9c, 0xa1, 0xb, 0x91, 0xb, + 0x2a, 0x9c, + + /* U+0065 "e" */ + 0x29, 0x98, 0x9, 0x98, 0xa1, 0x93, 0x6, 0x2, + 0xb9, 0x70, + + /* U+0066 "f" */ + 0x3b, 0x4a, 0xb1, 0x56, 0x5, 0x60, 0x56, 0x0, + + /* U+0067 "g" */ + 0x2a, 0x9c, 0xa1, 0xc, 0xa1, 0xb, 0x2a, 0x8d, + 0x49, 0x87, + + /* U+0068 "h" */ + 0x74, 0x0, 0x7a, 0xa8, 0x74, 0xb, 0x74, 0xb, + 0x74, 0xb, + + /* U+0069 "i" */ + 0x52, 0x73, 0x73, 0x73, 0x73, + + /* U+006A "j" */ + 0x5, 0x30, 0x74, 0x7, 0x40, 0x74, 0x7, 0x32, + 0xb1, + + /* U+006B "k" */ + 0x73, 0x0, 0x73, 0x94, 0x7c, 0x60, 0x75, 0xb0, + 0x73, 0x39, + + /* U+006C "l" */ + 0x73, 0x73, 0x73, 0x73, 0x73, + + /* U+006D "m" */ + 0x79, 0x99, 0x7b, 0x7, 0x40, 0xb0, 0x82, 0x73, + 0xb, 0x8, 0x27, 0x30, 0xb0, 0x82, + + /* U+006E "n" */ + 0x79, 0x78, 0x74, 0xb, 0x74, 0xb, 0x74, 0xb, + + /* U+006F "o" */ + 0x2a, 0x97, 0xa, 0x10, 0xa1, 0xa1, 0xa, 0x12, + 0xa9, 0x70, + + /* U+0070 "p" */ + 0x7a, 0x77, 0x7, 0x40, 0xa1, 0x74, 0xa, 0x7, + 0xa9, 0x70, 0x74, 0x0, 0x0, + + /* U+0071 "q" */ + 0x2a, 0x8c, 0xa1, 0xb, 0x91, 0xb, 0x2a, 0x9c, + 0x0, 0xb, + + /* U+0072 "r" */ + 0x7a, 0x67, 0x40, 0x73, 0x7, 0x30, + + /* U+0073 "s" */ + 0x59, 0xa3, 0x79, 0x41, 0x32, 0x78, 0x5a, 0xa5, + + /* U+0074 "t" */ + 0x1, 0x5, 0x50, 0xaa, 0x5, 0x50, 0x55, 0x3, + 0xb0, + + /* U+0075 "u" */ + 0x73, 0xb, 0x73, 0xb, 0x74, 0xc, 0x2b, 0x8b, + + /* U+0076 "v" */ + 0xa0, 0xa, 0x46, 0x65, 0xa, 0xa0, 0x8, 0x80, + + /* U+0077 "w" */ + 0xb0, 0x96, 0x19, 0x73, 0x99, 0x63, 0x2a, 0x7a, + 0xa0, 0xd, 0x26, 0x90, + + /* U+0078 "x" */ + 0x76, 0x57, 0xa, 0xa0, 0xb, 0xb0, 0x94, 0x49, + + /* U+0079 "y" */ + 0xa1, 0xa, 0x38, 0x64, 0xa, 0xa0, 0x6, 0x60, + 0x5b, 0x0, + + /* U+007A "z" */ + 0x58, 0xb9, 0x2, 0xa0, 0x1b, 0x0, 0xba, 0x97, + + /* U+007B "{" */ + 0xb, 0x40, 0xa0, 0x94, 0x0, 0x90, 0xa, 0x0, + 0xa4, + + /* U+007C "|" */ + 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, + + /* U+007D "}" */ + 0x87, 0x0, 0xa0, 0x9, 0x40, 0xa0, 0xa, 0x8, + 0x60, + + /* U+007E "~" */ + 0x7b, 0xbb, 0x30, + + /* U+00A0 " " */ + + /* U+00A3 "£" */ + 0x1a, 0x99, 0x5, 0x60, 0x30, 0x7d, 0x60, 0x1, + 0x90, 0x0, 0xa9, 0x9a, 0x10, 0x0, 0x0, + + /* U+00A4 "¤" */ + 0x0, 0x0, 0x6, 0xaa, 0xa0, 0x55, 0xa, 0x5, + 0x50, 0xa0, 0x6a, 0xaa, 0x0, 0x0, 0x0, + + /* U+00A5 "¥" */ + 0x92, 0xa, 0x20, 0xb6, 0x60, 0x6a, 0xe8, 0x15, + 0x9c, 0x81, 0x2, 0x90, 0x0, + + /* U+00A6 "¦" */ + 0x45, 0x45, 0x34, 0x34, 0x45, 0x45, + + /* U+00A7 "§" */ + 0x1a, 0xa6, 0x1, 0xb2, 0x20, 0x83, 0x99, 0x3, + 0x60, 0x90, 0x11, 0x38, 0x2, 0xb9, 0x70, + + /* U+00A8 "¨" */ + 0x83, 0x50, + + /* U+00A9 "©" */ + 0x5, 0x77, 0x40, 0x64, 0x77, 0x55, 0x87, 0x11, + 0x17, 0x77, 0x2, 0x27, 0x64, 0x77, 0x55, 0x4, + 0x77, 0x40, + + /* U+00AA "ª" */ + 0x77, 0xa9, 0x9, 0x77, 0xa0, + + /* U+00AB "«" */ + 0x2, 0x13, 0xa, 0x55, 0x38, 0xa1, 0x8, 0x38, + + /* U+00AC "¬" */ + 0x59, 0x9c, 0x30, 0x0, 0x73, 0x0, 0x0, 0x0, + + /* U+00AD "­" */ + 0x7a, 0x40, + + /* U+00AE "®" */ + 0x5, 0x77, 0x40, 0x67, 0x77, 0x45, 0x85, 0x28, + 0x7, 0x75, 0x89, 0x7, 0x67, 0x15, 0x55, 0x4, + 0x77, 0x40, + + /* U+00B0 "°" */ + 0x17, 0x36, 0x7, 0x17, 0x30, + + /* U+00B1 "±" */ + 0x0, 0x60, 0x0, 0xa, 0x0, 0x59, 0xd9, 0x20, + 0xa, 0x0, 0x5a, 0xaa, 0x20, + + /* U+00B2 "²" */ + 0x68, 0x50, 0x83, 0x9a, 0x40, + + /* U+00B3 "³" */ + 0x69, 0x40, 0x93, 0x68, 0x50, + + /* U+00B5 "µ" */ + 0x74, 0xb, 0x74, 0xb, 0x74, 0xc, 0x7b, 0x9d, + 0x74, 0x0, + + /* U+00B6 "¶" */ + 0x8, 0xfb, 0xe3, 0xf, 0xf3, 0xa0, 0x5, 0xc3, + 0xa0, 0x0, 0x73, 0xa0, 0x0, 0x73, 0xa0, 0x0, + 0x73, 0xa0, + + /* U+00B7 "·" */ + 0x36, + + /* U+00BB "»" */ + 0x11, 0x30, 0xa, 0x64, 0x9, 0x4a, 0x27, 0x81, + + /* U+00BD "½" */ + 0x3b, 0x0, 0x36, 0x0, 0x90, 0x8, 0x0, 0x7, + 0x8, 0x10, 0x0, 0x6, 0x35, 0x73, 0x3, 0x60, + 0x6, 0x20, 0x70, 0x7, 0x94, + + /* U+0384 "΄" */ + 0xa, 0x0, 0x0, + + /* U+0386 "Ά" */ + 0x85, 0xe3, 0x0, 0x7, 0x6b, 0x0, 0xc, 0xa, + 0x30, 0x5d, 0x9b, 0xa0, 0xb1, 0x0, 0xc2, + + /* U+0388 "Έ" */ + 0x1a, 0x7c, 0xaa, 0x70, 0x7, 0x50, 0x0, 0x0, + 0x7b, 0xaa, 0x50, 0x7, 0x50, 0x0, 0x0, 0x7c, + 0xaa, 0x80, + + /* U+0389 "Ή" */ + 0x1a, 0x92, 0x0, 0xc0, 0x9, 0x20, 0xc, 0x0, + 0x9b, 0xaa, 0xd0, 0x9, 0x20, 0xc, 0x0, 0x92, + 0x0, 0xc0, + + /* U+038A "Ί" */ + 0x1a, 0x92, 0x0, 0x92, 0x0, 0x92, 0x0, 0x92, + 0x0, 0x92, + + /* U+038C "Ό" */ + 0x1a, 0x8a, 0x99, 0x0, 0x76, 0x0, 0x49, 0x9, + 0x20, 0x0, 0xc0, 0x66, 0x0, 0x49, 0x0, 0x8a, + 0x99, 0x0, + + /* U+038E "Ύ" */ + 0x1a, 0x2b, 0x0, 0x85, 0x0, 0x6, 0x74, 0x80, + 0x0, 0x0, 0x9a, 0x0, 0x0, 0x0, 0x57, 0x0, + 0x0, 0x0, 0x57, 0x0, + + /* U+038F "Ώ" */ + 0x1a, 0x7a, 0xa8, 0x0, 0x58, 0x0, 0x76, 0x7, + 0x40, 0x3, 0x80, 0x28, 0x0, 0x73, 0x5, 0xd8, + 0x6d, 0x60, + + /* U+0390 "ΐ" */ + 0x65, 0x73, 0x7, 0x30, 0x7, 0x30, 0x7, 0x30, + 0x7, 0x30, + + /* U+0391 "Α" */ + 0x1, 0xe3, 0x0, 0x7, 0x6b, 0x0, 0xc, 0xa, + 0x30, 0x5d, 0x9b, 0xa0, 0xb1, 0x0, 0xc2, + + /* U+0392 "Β" */ + 0x6c, 0xab, 0x46, 0x50, 0x28, 0x6c, 0xad, 0x46, + 0x50, 0xc, 0x6c, 0xaa, 0x70, + + /* U+0393 "Γ" */ + 0x5c, 0xaa, 0x25, 0x60, 0x0, 0x56, 0x0, 0x5, + 0x60, 0x0, 0x56, 0x0, 0x0, + + /* U+0394 "Δ" */ + 0x0, 0x1e, 0x30, 0x0, 0x7, 0x5a, 0x0, 0x0, + 0xb0, 0x93, 0x0, 0x56, 0x2, 0xa0, 0xc, 0xaa, + 0xae, 0x20, + + /* U+0395 "Ε" */ + 0x5c, 0xaa, 0x85, 0x60, 0x0, 0x5c, 0xaa, 0x55, + 0x60, 0x0, 0x5c, 0xaa, 0x90, + + /* U+0396 "Ζ" */ + 0x5a, 0xad, 0x80, 0x3, 0xa0, 0x3, 0xb0, 0x2, + 0xb0, 0x0, 0xcb, 0xaa, 0x60, + + /* U+0397 "Η" */ + 0x56, 0x0, 0xa2, 0x56, 0x0, 0xa2, 0x5c, 0xaa, + 0xd2, 0x56, 0x0, 0xa2, 0x56, 0x0, 0xa2, + + /* U+0398 "Θ" */ + 0x8, 0xa9, 0x90, 0x57, 0x0, 0x39, 0x93, 0xaa, + 0x2c, 0x67, 0x0, 0x39, 0x8, 0xa9, 0x90, + + /* U+0399 "Ι" */ + 0x48, 0x48, 0x48, 0x48, 0x48, + + /* U+039A "Κ" */ + 0x65, 0x6, 0x90, 0x65, 0x87, 0x0, 0x6d, 0xb3, + 0x0, 0x66, 0xc, 0x20, 0x65, 0x2, 0xc1, + + /* U+039B "Λ" */ + 0x0, 0xd4, 0x0, 0x6, 0x5a, 0x0, 0xb, 0x9, + 0x20, 0x47, 0x2, 0x90, 0xb1, 0x0, 0xb1, + + /* U+039C "Μ" */ + 0x6e, 0x0, 0x2f, 0x16, 0xb5, 0x8, 0xb1, 0x65, + 0xa0, 0x9a, 0x16, 0x59, 0x64, 0xa1, 0x65, 0x3d, + 0xa, 0x10, + + /* U+039D "Ν" */ + 0x5c, 0x0, 0x92, 0x5a, 0x80, 0x92, 0x55, 0x85, + 0x92, 0x55, 0xb, 0xb2, 0x55, 0x1, 0xe2, + + /* U+039E "Ξ" */ + 0x4a, 0xaa, 0x60, 0x0, 0x0, 0xa, 0xaa, 0x20, + 0x0, 0x0, 0x5a, 0xaa, 0x80, + + /* U+039F "Ο" */ + 0x8, 0xa9, 0x90, 0x57, 0x0, 0x39, 0x93, 0x0, + 0xc, 0x67, 0x0, 0x39, 0x8, 0xa9, 0x90, + + /* U+03A0 "Π" */ + 0x5c, 0xaa, 0xd2, 0x56, 0x0, 0xa2, 0x56, 0x0, + 0xa2, 0x56, 0x0, 0xa2, 0x56, 0x0, 0xa2, + + /* U+03A1 "Ρ" */ + 0x6c, 0xaa, 0x86, 0x60, 0xd, 0x6c, 0x9a, 0x56, + 0x60, 0x0, 0x66, 0x0, 0x0, + + /* U+03A3 "Σ" */ + 0x6d, 0xaa, 0x40, 0x85, 0x0, 0x0, 0xc1, 0x0, + 0x94, 0x0, 0x6d, 0xaa, 0x60, + + /* U+03A4 "Τ" */ + 0x8a, 0xea, 0x70, 0xc, 0x0, 0x0, 0xc0, 0x0, + 0xc, 0x0, 0x0, 0xc0, 0x0, + + /* U+03A5 "Υ" */ + 0x95, 0x1, 0xb0, 0xb, 0x2a, 0x20, 0x1, 0xd4, + 0x0, 0x0, 0xc0, 0x0, 0x0, 0xc0, 0x0, + + /* U+03A6 "Φ" */ + 0x7, 0xbd, 0x91, 0x6, 0x73, 0x91, 0xb0, 0xa2, + 0x39, 0xb, 0x6, 0x73, 0x91, 0xb0, 0x7, 0xad, + 0x91, 0x0, 0x2, 0x60, 0x0, + + /* U+03A7 "Χ" */ + 0x49, 0x2, 0xa0, 0x7, 0x7b, 0x0, 0x0, 0xe5, + 0x0, 0xa, 0x4b, 0x20, 0x85, 0x2, 0xb0, + + /* U+03A8 "Ψ" */ + 0x84, 0xb, 0x9, 0x37, 0x40, 0xb0, 0x92, 0x48, + 0xb, 0xc, 0x0, 0x79, 0xe9, 0x30, 0x0, 0xb, + 0x0, 0x0, + + /* U+03A9 "Ω" */ + 0x8, 0xaa, 0x80, 0x68, 0x0, 0x85, 0x84, 0x0, + 0x48, 0x38, 0x0, 0x83, 0x6d, 0x77, 0xd6, + + /* U+03AA "Ϊ" */ + 0x86, 0x20, 0x0, 0x47, 0x4, 0x70, 0x47, 0x4, + 0x70, 0x47, 0x0, + + /* U+03AB "Ϋ" */ + 0x5, 0x38, 0x0, 0x0, 0x0, 0x0, 0x95, 0x1, + 0xb0, 0xb, 0x2a, 0x20, 0x1, 0xd4, 0x0, 0x0, + 0xc0, 0x0, 0x0, 0xc0, 0x0, + + /* U+03AC "ά" */ + 0x0, 0xb0, 0x3, 0xa8, 0xb2, 0xa2, 0xc, 0xa, + 0x20, 0xc0, 0x39, 0x8b, 0x20, + + /* U+03AD "έ" */ + 0x5, 0x60, 0x4a, 0x90, 0x3c, 0x20, 0x83, 0x0, + 0x4a, 0xa2, + + /* U+03AE "ή" */ + 0x0, 0xa0, 0x79, 0x78, 0x74, 0xb, 0x74, 0xb, + 0x74, 0xb, 0x0, 0xb, + + /* U+03AF "ί" */ + 0x57, 0x73, 0x73, 0x73, 0x73, + + /* U+03B0 "ΰ" */ + 0x26, 0x67, 0x73, 0xb, 0x73, 0xb, 0x64, 0xb, + 0x1a, 0x96, + + /* U+03B1 "α" */ + 0x3a, 0x7b, 0x2a, 0x20, 0xc0, 0xa2, 0xc, 0x3, + 0x98, 0xb2, + + /* U+03B2 "β" */ + 0x2a, 0x99, 0x6, 0x59, 0x70, 0x74, 0xb, 0x17, + 0x40, 0x82, 0x7a, 0x89, 0x7, 0x40, 0x0, + + /* U+03B3 "γ" */ + 0xa1, 0x1a, 0x47, 0x74, 0xa, 0xa0, 0x7, 0x70, + 0x5, 0x50, + + /* U+03B4 "δ" */ + 0x2b, 0x86, 0x3, 0xa6, 0x20, 0xa1, 0x9, 0x9, + 0x10, 0xa1, 0x2a, 0x98, 0x0, + + /* U+03B5 "ε" */ + 0x4a, 0x90, 0x3c, 0x20, 0x83, 0x0, 0x4a, 0xa2, + + /* U+03B6 "ζ" */ + 0x8, 0xd4, 0x8, 0x20, 0x64, 0x0, 0xa1, 0x0, + 0x5e, 0xc2, 0x0, 0x82, + + /* U+03B7 "η" */ + 0x79, 0x78, 0x74, 0xb, 0x74, 0xb, 0x74, 0xb, + 0x0, 0xb, + + /* U+03B8 "θ" */ + 0x1a, 0x96, 0x8, 0x30, 0xb0, 0x99, 0x8d, 0x18, + 0x30, 0xb0, 0x1a, 0x96, 0x0, + + /* U+03B9 "ι" */ + 0x73, 0x73, 0x73, 0x73, + + /* U+03BA "κ" */ + 0x73, 0x95, 0x7d, 0x40, 0x77, 0xa0, 0x73, 0x59, + + /* U+03BB "λ" */ + 0xb, 0x0, 0x7, 0x60, 0xa, 0xa0, 0x46, 0x74, + 0xa1, 0x1a, + + /* U+03BC "μ" */ + 0x74, 0xb, 0x74, 0xb, 0x74, 0xc, 0x7b, 0x9d, + 0x74, 0x0, + + /* U+03BD "ν" */ + 0xa0, 0xa, 0x46, 0x65, 0xa, 0xa0, 0x8, 0x80, + + /* U+03BE "ξ" */ + 0x39, 0x80, 0x1b, 0x90, 0x65, 0x0, 0x84, 0x0, + 0x6, 0xa3, 0x0, 0xa3, + + /* U+03BF "ο" */ + 0x2a, 0x97, 0xa, 0x10, 0xa1, 0xa1, 0xa, 0x12, + 0xa9, 0x70, + + /* U+03C0 "π" */ + 0x7d, 0x8a, 0xb2, 0xb, 0x4, 0x60, 0xb, 0x4, + 0x60, 0xb, 0x4, 0x60, + + /* U+03C1 "ρ" */ + 0x1a, 0x98, 0x6, 0x40, 0x82, 0x74, 0x8, 0x27, + 0xa8, 0x90, 0x73, 0x0, 0x0, + + /* U+03C2 "ς" */ + 0x19, 0x86, 0x82, 0x0, 0x75, 0x0, 0x4, 0x94, + 0x4, 0xb5, + + /* U+03C3 "σ" */ + 0x2b, 0xbe, 0x7a, 0x10, 0xa1, 0xa1, 0xa, 0x12, + 0xa9, 0x70, + + /* U+03C4 "τ" */ + 0x6d, 0x80, 0xb0, 0xb, 0x0, 0xb0, + + /* U+03C5 "υ" */ + 0x73, 0xb, 0x73, 0xb, 0x64, 0xb, 0x1a, 0x96, + + /* U+03C6 "φ" */ + 0x39, 0x89, 0x5a, 0x1b, 0xb, 0x92, 0xb0, 0xa1, + 0xad, 0xa2, 0x0, 0xb0, 0x0, + + /* U+03C7 "χ" */ + 0x83, 0x1a, 0x0, 0xa9, 0x20, 0x7, 0xa0, 0x1, + 0xa8, 0x30, 0x92, 0xb, 0x0, + + /* U+03C8 "ψ" */ + 0x82, 0x83, 0x73, 0x82, 0x83, 0x73, 0x74, 0x83, + 0x82, 0x1a, 0xca, 0x90, 0x0, 0x83, 0x0, + + /* U+03C9 "ω" */ + 0x47, 0x0, 0x38, 0x92, 0x37, 0xb, 0x92, 0x48, + 0xc, 0x3a, 0x87, 0x96, + + /* U+03CA "ϊ" */ + 0x26, 0x80, 0x73, 0x7, 0x30, 0x73, 0x7, 0x30, + + /* U+03CB "ϋ" */ + 0x8, 0x53, 0x73, 0xb, 0x73, 0xb, 0x64, 0xb, + 0x1a, 0x96, + + /* U+03CC "ό" */ + 0x0, 0xa0, 0x2, 0xa9, 0x70, 0xa1, 0xa, 0x1a, + 0x10, 0xa1, 0x2a, 0x97, 0x0, + + /* U+03CD "ύ" */ + 0x1, 0xa0, 0x73, 0xb, 0x73, 0xb, 0x64, 0xb, + 0x1a, 0x96, + + /* U+03CE "ώ" */ + 0x0, 0x1a, 0x0, 0x47, 0x0, 0x38, 0x92, 0x37, + 0xb, 0x92, 0x48, 0xc, 0x3a, 0x87, 0x96, + + /* U+03F4 "ϴ" */ + 0x17, 0x67 +}; + + +/*--------------------- + * GLYPH DESCRIPTION + *--------------------*/ + +static const lv_font_fmt_txt_glyph_dsc_t glyph_dsc[] = { + {.bitmap_index = 0, .adv_w = 0, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0} /* id = 0 reserved */, + {.bitmap_index = 0, .adv_w = 36, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 0, .adv_w = 36, .box_w = 2, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 5, .adv_w = 45, .box_w = 3, .box_h = 2, .ofs_x = 0, .ofs_y = 3}, + {.bitmap_index = 8, .adv_w = 71, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 21, .adv_w = 71, .box_w = 5, .box_h = 7, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 39, .adv_w = 114, .box_w = 7, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 57, .adv_w = 85, .box_w = 6, .box_h = 6, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 75, .adv_w = 24, .box_w = 2, .box_h = 2, .ofs_x = 0, .ofs_y = 3}, + {.bitmap_index = 77, .adv_w = 43, .box_w = 3, .box_h = 6, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 86, .adv_w = 43, .box_w = 3, .box_h = 6, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 95, .adv_w = 50, .box_w = 3, .box_h = 3, .ofs_x = 0, .ofs_y = 2}, + {.bitmap_index = 100, .adv_w = 75, .box_w = 5, .box_h = 4, .ofs_x = 0, .ofs_y = 1}, + {.bitmap_index = 110, .adv_w = 36, .box_w = 2, .box_h = 3, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 113, .adv_w = 43, .box_w = 3, .box_h = 1, .ofs_x = 0, .ofs_y = 1}, + {.bitmap_index = 115, .adv_w = 36, .box_w = 2, .box_h = 1, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 116, .adv_w = 36, .box_w = 3, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 124, .adv_w = 71, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 137, .adv_w = 71, .box_w = 3, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 145, .adv_w = 71, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 158, .adv_w = 71, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 171, .adv_w = 71, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 184, .adv_w = 71, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 197, .adv_w = 71, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 210, .adv_w = 71, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 223, .adv_w = 71, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 236, .adv_w = 71, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 249, .adv_w = 36, .box_w = 2, .box_h = 4, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 253, .adv_w = 36, .box_w = 2, .box_h = 6, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 259, .adv_w = 75, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 272, .adv_w = 75, .box_w = 5, .box_h = 2, .ofs_x = 0, .ofs_y = 2}, + {.bitmap_index = 277, .adv_w = 75, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 290, .adv_w = 71, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 303, .adv_w = 130, .box_w = 8, .box_h = 6, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 327, .adv_w = 85, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 342, .adv_w = 85, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 355, .adv_w = 92, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 370, .adv_w = 92, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 385, .adv_w = 85, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 398, .adv_w = 78, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 411, .adv_w = 100, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 426, .adv_w = 92, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 441, .adv_w = 36, .box_w = 2, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 446, .adv_w = 64, .box_w = 4, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 456, .adv_w = 85, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 471, .adv_w = 71, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 484, .adv_w = 107, .box_w = 7, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 502, .adv_w = 92, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 517, .adv_w = 100, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 532, .adv_w = 85, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 545, .adv_w = 100, .box_w = 6, .box_h = 6, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 563, .adv_w = 92, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 578, .adv_w = 85, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 591, .adv_w = 78, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 604, .adv_w = 92, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 619, .adv_w = 85, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 634, .adv_w = 121, .box_w = 8, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 654, .adv_w = 85, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 669, .adv_w = 85, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 684, .adv_w = 78, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 697, .adv_w = 36, .box_w = 3, .box_h = 6, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 706, .adv_w = 36, .box_w = 3, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 714, .adv_w = 36, .box_w = 2, .box_h = 6, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 720, .adv_w = 60, .box_w = 4, .box_h = 3, .ofs_x = 0, .ofs_y = 3}, + {.bitmap_index = 726, .adv_w = 71, .box_w = 6, .box_h = 1, .ofs_x = -1, .ofs_y = -2}, + {.bitmap_index = 729, .adv_w = 43, .box_w = 2, .box_h = 2, .ofs_x = 0, .ofs_y = 4}, + {.bitmap_index = 731, .adv_w = 71, .box_w = 5, .box_h = 4, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 741, .adv_w = 71, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 754, .adv_w = 64, .box_w = 4, .box_h = 4, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 762, .adv_w = 71, .box_w = 4, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 772, .adv_w = 71, .box_w = 5, .box_h = 4, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 782, .adv_w = 36, .box_w = 3, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 790, .adv_w = 71, .box_w = 4, .box_h = 5, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 800, .adv_w = 71, .box_w = 4, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 810, .adv_w = 28, .box_w = 2, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 815, .adv_w = 28, .box_w = 3, .box_h = 6, .ofs_x = -1, .ofs_y = -1}, + {.bitmap_index = 824, .adv_w = 64, .box_w = 4, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 834, .adv_w = 28, .box_w = 2, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 839, .adv_w = 107, .box_w = 7, .box_h = 4, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 853, .adv_w = 71, .box_w = 4, .box_h = 4, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 861, .adv_w = 71, .box_w = 5, .box_h = 4, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 871, .adv_w = 71, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 884, .adv_w = 71, .box_w = 4, .box_h = 5, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 894, .adv_w = 43, .box_w = 3, .box_h = 4, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 900, .adv_w = 64, .box_w = 4, .box_h = 4, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 908, .adv_w = 36, .box_w = 3, .box_h = 6, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 917, .adv_w = 71, .box_w = 4, .box_h = 4, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 925, .adv_w = 64, .box_w = 4, .box_h = 4, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 933, .adv_w = 92, .box_w = 6, .box_h = 4, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 945, .adv_w = 64, .box_w = 4, .box_h = 4, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 953, .adv_w = 64, .box_w = 4, .box_h = 5, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 963, .adv_w = 64, .box_w = 4, .box_h = 4, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 971, .adv_w = 43, .box_w = 3, .box_h = 6, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 980, .adv_w = 33, .box_w = 2, .box_h = 6, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 986, .adv_w = 43, .box_w = 3, .box_h = 6, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 995, .adv_w = 75, .box_w = 5, .box_h = 1, .ofs_x = 0, .ofs_y = 2}, + {.bitmap_index = 998, .adv_w = 36, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 998, .adv_w = 71, .box_w = 5, .box_h = 6, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 1013, .adv_w = 71, .box_w = 5, .box_h = 6, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1028, .adv_w = 71, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1041, .adv_w = 33, .box_w = 2, .box_h = 6, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 1047, .adv_w = 71, .box_w = 5, .box_h = 6, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 1062, .adv_w = 43, .box_w = 3, .box_h = 1, .ofs_x = 0, .ofs_y = 5}, + {.bitmap_index = 1064, .adv_w = 94, .box_w = 6, .box_h = 6, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1082, .adv_w = 48, .box_w = 3, .box_h = 3, .ofs_x = 0, .ofs_y = 3}, + {.bitmap_index = 1087, .adv_w = 71, .box_w = 4, .box_h = 4, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1095, .adv_w = 75, .box_w = 5, .box_h = 3, .ofs_x = 0, .ofs_y = 1}, + {.bitmap_index = 1103, .adv_w = 43, .box_w = 3, .box_h = 1, .ofs_x = 0, .ofs_y = 1}, + {.bitmap_index = 1105, .adv_w = 94, .box_w = 6, .box_h = 6, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1123, .adv_w = 51, .box_w = 3, .box_h = 3, .ofs_x = 0, .ofs_y = 3}, + {.bitmap_index = 1128, .adv_w = 75, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1141, .adv_w = 43, .box_w = 3, .box_h = 3, .ofs_x = 0, .ofs_y = 3}, + {.bitmap_index = 1146, .adv_w = 43, .box_w = 3, .box_h = 3, .ofs_x = 0, .ofs_y = 3}, + {.bitmap_index = 1151, .adv_w = 71, .box_w = 4, .box_h = 5, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 1161, .adv_w = 69, .box_w = 6, .box_h = 6, .ofs_x = -1, .ofs_y = -1}, + {.bitmap_index = 1179, .adv_w = 36, .box_w = 2, .box_h = 1, .ofs_x = 0, .ofs_y = 2}, + {.bitmap_index = 1180, .adv_w = 71, .box_w = 4, .box_h = 4, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1188, .adv_w = 107, .box_w = 7, .box_h = 6, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1209, .adv_w = 43, .box_w = 3, .box_h = 2, .ofs_x = 0, .ofs_y = 4}, + {.bitmap_index = 1212, .adv_w = 85, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1227, .adv_w = 100, .box_w = 7, .box_h = 5, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 1245, .adv_w = 107, .box_w = 7, .box_h = 5, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 1263, .adv_w = 49, .box_w = 4, .box_h = 5, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 1273, .adv_w = 99, .box_w = 7, .box_h = 5, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 1291, .adv_w = 110, .box_w = 8, .box_h = 5, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 1311, .adv_w = 96, .box_w = 7, .box_h = 5, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 1329, .adv_w = 28, .box_w = 4, .box_h = 5, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 1339, .adv_w = 85, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1354, .adv_w = 85, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1367, .adv_w = 71, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1380, .adv_w = 86, .box_w = 7, .box_h = 5, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 1398, .adv_w = 85, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1411, .adv_w = 78, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1424, .adv_w = 92, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1439, .adv_w = 100, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1454, .adv_w = 36, .box_w = 2, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1459, .adv_w = 85, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1474, .adv_w = 86, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1489, .adv_w = 107, .box_w = 7, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1507, .adv_w = 92, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1522, .adv_w = 83, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1535, .adv_w = 100, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1550, .adv_w = 92, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1565, .adv_w = 85, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1578, .adv_w = 79, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1591, .adv_w = 78, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1604, .adv_w = 85, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1619, .adv_w = 102, .box_w = 7, .box_h = 6, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 1640, .adv_w = 85, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1655, .adv_w = 107, .box_w = 7, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1673, .adv_w = 96, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1688, .adv_w = 36, .box_w = 3, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1699, .adv_w = 85, .box_w = 6, .box_h = 7, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1720, .adv_w = 74, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1733, .adv_w = 57, .box_w = 4, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1743, .adv_w = 71, .box_w = 4, .box_h = 6, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 1755, .adv_w = 28, .box_w = 2, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1760, .adv_w = 70, .box_w = 4, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1770, .adv_w = 74, .box_w = 5, .box_h = 4, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1780, .adv_w = 74, .box_w = 5, .box_h = 6, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 1795, .adv_w = 64, .box_w = 4, .box_h = 5, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 1805, .adv_w = 71, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1818, .adv_w = 57, .box_w = 4, .box_h = 4, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1826, .adv_w = 56, .box_w = 4, .box_h = 6, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 1838, .adv_w = 71, .box_w = 4, .box_h = 5, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 1848, .adv_w = 71, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1861, .adv_w = 28, .box_w = 2, .box_h = 4, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1865, .adv_w = 64, .box_w = 4, .box_h = 4, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1873, .adv_w = 64, .box_w = 4, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1883, .adv_w = 71, .box_w = 4, .box_h = 5, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 1893, .adv_w = 64, .box_w = 4, .box_h = 4, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1901, .adv_w = 57, .box_w = 4, .box_h = 6, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 1913, .adv_w = 71, .box_w = 5, .box_h = 4, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1923, .adv_w = 88, .box_w = 6, .box_h = 4, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1935, .adv_w = 73, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 1948, .adv_w = 62, .box_w = 4, .box_h = 5, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 1958, .adv_w = 79, .box_w = 5, .box_h = 4, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1968, .adv_w = 51, .box_w = 3, .box_h = 4, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1974, .adv_w = 70, .box_w = 4, .box_h = 4, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1982, .adv_w = 83, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 1995, .adv_w = 67, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 2008, .adv_w = 91, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 2023, .adv_w = 100, .box_w = 6, .box_h = 4, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2035, .adv_w = 28, .box_w = 3, .box_h = 5, .ofs_x = -1, .ofs_y = 0}, + {.bitmap_index = 2043, .adv_w = 70, .box_w = 4, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2053, .adv_w = 71, .box_w = 5, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2066, .adv_w = 70, .box_w = 4, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2076, .adv_w = 100, .box_w = 6, .box_h = 5, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 2091, .adv_w = 43, .box_w = 4, .box_h = 1, .ofs_x = -1, .ofs_y = 4} +}; + +/*--------------------- + * CHARACTER MAPPING + *--------------------*/ + +static const uint8_t glyph_id_ofs_list_1[] = { + 0, 0, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 0, + 13, 14, 15, 16, 0, 17, 18, 19, + 0, 0, 0, 20, 0, 21 +}; + +static const uint8_t glyph_id_ofs_list_2[] = { + 0, 0, 1, 0, 2, 3, 4, 0, + 5 +}; + +/*Collect the unicode lists and glyph_id offsets*/ +static const lv_font_fmt_txt_cmap_t cmaps[] = +{ + { + .range_start = 32, .range_length = 95, .glyph_id_start = 1, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 160, .range_length = 30, .glyph_id_start = 96, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_1, .list_length = 30, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 900, .range_length = 9, .glyph_id_start = 118, + .unicode_list = NULL, .glyph_id_ofs_list = glyph_id_ofs_list_2, .list_length = 9, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL + }, + { + .range_start = 910, .range_length = 20, .glyph_id_start = 124, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 931, .range_length = 44, .glyph_id_start = 144, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 1012, .range_length = 1, .glyph_id_start = 188, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + } +}; + + + +/*-------------------- + * ALL CUSTOM DATA + *--------------------*/ + +#if LVGL_VERSION_MAJOR == 8 +/*Store all the custom data of the font*/ +static lv_font_fmt_txt_glyph_cache_t cache; +#endif + +#if LVGL_VERSION_MAJOR >= 8 +static const lv_font_fmt_txt_dsc_t font_dsc = { +#else +static lv_font_fmt_txt_dsc_t font_dsc = { +#endif + .glyph_bitmap = glyph_bitmap, + .glyph_dsc = glyph_dsc, + .cmaps = cmaps, + .kern_dsc = NULL, + .kern_scale = 0, + .cmap_num = 6, + .bpp = 4, + .kern_classes = 0, + .bitmap_format = 0, +#if LVGL_VERSION_MAJOR == 8 + .cache = &cache +#endif + +}; + +extern const lv_font_t lv_font_montserrat_8; + + +/*----------------- + * PUBLIC FONT + *----------------*/ + +/*Initialize a public general font descriptor*/ +#if LVGL_VERSION_MAJOR >= 8 +const lv_font_t lv_font_arial_8 = { +#else +lv_font_t lv_font_arial_8 = { +#endif + .get_glyph_dsc = lv_font_get_glyph_dsc_fmt_txt, /*Function pointer to get glyph's data*/ + .get_glyph_bitmap = lv_font_get_bitmap_fmt_txt, /*Function pointer to get glyph's bitmap*/ + .line_height = 9, /*The maximum line height required by the font*/ + .base_line = 2, /*Baseline measured from the bottom of the line*/ +#if !(LVGL_VERSION_MAJOR == 6 && LVGL_VERSION_MINOR == 0) + .subpx = LV_FONT_SUBPX_NONE, +#endif +#if LV_VERSION_CHECK(7, 4, 0) || LVGL_VERSION_MAJOR >= 8 + .underline_position = -1, + .underline_thickness = 1, +#endif + //.static_bitmap = 0, + .dsc = &font_dsc, /*The custom font data. Will be accessed by `get_glyph_bitmap/dsc` */ +#if LV_VERSION_CHECK(8, 2, 0) || LVGL_VERSION_MAJOR >= 9 + .fallback = &lv_font_montserrat_8, +#endif + .user_data = NULL, +}; + + + +#endif /*#if LV_FONT_ARIAL_8*/ diff --git a/src/helpers/BaseChatMesh.cpp b/src/helpers/BaseChatMesh.cpp index 7ddc461d29..d09bacfc39 100644 --- a/src/helpers/BaseChatMesh.cpp +++ b/src/helpers/BaseChatMesh.cpp @@ -132,7 +132,7 @@ void BaseChatMesh::onAdvertRecv(mesh::Packet* packet, const mesh::Identity& id, packet->header = save; } - bool is_new = false; // true = not in contacts[], false = exists in contacts[] + bool is_new = false; // true = newly discovered (not previously in contacts[]), false = existing contact if (from == NULL) { if (!shouldAutoAddContactType(parser.getType())) { ContactInfo ci; @@ -159,10 +159,11 @@ void BaseChatMesh::onAdvertRecv(mesh::Packet* packet, const mesh::Identity& id, MESH_DEBUG_PRINTLN("onAdvertRecv: unable to allocate contact slot for new contact"); return; } - + populateContactFromAdvert(*from, id, parser, timestamp); from->sync_since = 0; from->shared_secret_valid = false; + is_new = true; // slot was just allocated for a brand-new contact } // update putBlobByKey(id.pub_key, PUB_KEY_SIZE, temp_buf, plen); diff --git a/src/helpers/CommonCLI.cpp b/src/helpers/CommonCLI.cpp index b71afc72e2..b6cc410328 100644 --- a/src/helpers/CommonCLI.cpp +++ b/src/helpers/CommonCLI.cpp @@ -226,15 +226,15 @@ void CommonCLI::handleCommand(uint32_t sender_timestamp, char* command, char* re _callbacks->sendSelfAdvertisement(1500, true); // longer delay, give CLI response time to be sent first strcpy(reply, "OK - Advert sent"); } else if (memcmp(command, "clock sync", 10) == 0) { - uint32_t curr = getRTCClock()->getCurrentTime(); - if (sender_timestamp > curr) { + //uint32_t curr = getRTCClock()->getCurrentTime(); + //if (sender_timestamp > curr) { getRTCClock()->setCurrentTime(sender_timestamp + 1); uint32_t now = getRTCClock()->getCurrentTime(); DateTime dt = DateTime(now); sprintf(reply, "OK - clock set: %02d:%02d - %d/%d/%d UTC", dt.hour(), dt.minute(), dt.day(), dt.month(), dt.year()); - } else { - strcpy(reply, "ERR: clock cannot go backwards"); - } + //} else { + // strcpy(reply, "ERR: clock cannot go backwards"); + //} } else if (memcmp(command, "start ota", 9) == 0) { if (!_board->startOTAUpdate(_prefs->node_name, reply)) { strcpy(reply, "Error"); @@ -245,15 +245,15 @@ void CommonCLI::handleCommand(uint32_t sender_timestamp, char* command, char* re sprintf(reply, "%02d:%02d - %d/%d/%d UTC", dt.hour(), dt.minute(), dt.day(), dt.month(), dt.year()); } else if (memcmp(command, "time ", 5) == 0) { // set time (to epoch seconds) uint32_t secs = _atoi(&command[5]); - uint32_t curr = getRTCClock()->getCurrentTime(); - if (secs > curr) { + //int32_t curr = getRTCClock()->getCurrentTime(); + //if (secs > curr) { getRTCClock()->setCurrentTime(secs); uint32_t now = getRTCClock()->getCurrentTime(); DateTime dt = DateTime(now); sprintf(reply, "OK - clock set: %02d:%02d - %d/%d/%d UTC", dt.hour(), dt.minute(), dt.day(), dt.month(), dt.year()); - } else { - strcpy(reply, "(ERR: clock cannot go backwards)"); - } + //} else { + // strcpy(reply, "(ERR: clock cannot go backwards)"); + //} } else if (memcmp(command, "neighbors", 9) == 0) { _callbacks->formatNeighborsReply(reply); } else if (memcmp(command, "neighbor.remove ", 16) == 0) { diff --git a/src/helpers/esp32/ESPNOWRadio.cpp b/src/helpers/esp32/ESPNOWRadio.cpp index a7557f14e9..18e9902061 100644 --- a/src/helpers/esp32/ESPNOWRadio.cpp +++ b/src/helpers/esp32/ESPNOWRadio.cpp @@ -3,12 +3,53 @@ #include #include -static uint8_t broadcastAddress[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; -static esp_now_peer_info_t peerInfo; -static volatile bool is_send_complete = false; -static esp_err_t last_send_result; -static uint8_t rx_buf[256]; -static uint8_t last_rx_len = 0; + static uint8_t broadcastAddress[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; + static esp_now_peer_info_t peerInfo; + static volatile bool is_send_complete = false; + static esp_err_t last_send_result; + static uint8_t rx_buf[256]; + static uint8_t last_rx_len = 0; + static char bridge_secret[16]; + +#ifdef CLIENT_WITHOUT_LORA + static constexpr uint16_t BRIDGE_PACKET_MAGIC = 0xC03E; + static const size_t MAX_ESPNOW_PACKET_SIZE = 250; + /** + * @brief Common field sizes used by bridge implementations + * + * These constants define the size of common packet fields used across bridges. + * BRIDGE_MAGIC_SIZE is used by all bridges for packet identification. + * BRIDGE_LENGTH_SIZE is used by bridges that need explicit length fields (like RS232). + * BRIDGE_CHECKSUM_SIZE is used by all bridges for Fletcher-16 checksums. + */ + static constexpr uint16_t BRIDGE_MAGIC_SIZE = sizeof(BRIDGE_PACKET_MAGIC); + static constexpr uint16_t BRIDGE_LENGTH_SIZE = sizeof(uint16_t); + static constexpr uint16_t BRIDGE_CHECKSUM_SIZE = sizeof(uint16_t); + + static void xorCrypt(uint8_t *data, size_t len) { + size_t keyLen = strlen(bridge_secret); + for (size_t i = 0; i < len; i++) { + data[i] ^= bridge_secret[i % keyLen]; + } + } + + static uint16_t fletcher16(const uint8_t *data, size_t len) { + uint8_t sum1 = 0, sum2 = 0; + + for (size_t i = 0; i < len; i++) { + sum1 = (sum1 + data[i]) % 255; + sum2 = (sum2 + sum1) % 255; + } + + return (sum2 << 8) | sum1; + } + + static bool validateChecksum(const uint8_t *data, size_t len, uint16_t received_checksum) { + uint16_t calculated_checksum = fletcher16(data, len); + return received_checksum == calculated_checksum; + } + +#endif // callback when data is sent static void OnDataSent(const uint8_t *mac_addr, esp_now_send_status_t status) { @@ -18,13 +59,38 @@ static void OnDataSent(const uint8_t *mac_addr, esp_now_send_status_t status) { static void OnDataRecv(const uint8_t *mac, const uint8_t *data, int len) { ESPNOW_DEBUG_PRINTLN("Recv: len = %d", len); - memcpy(rx_buf, data, len); - last_rx_len = len; + + #ifdef CLIENT_WITHOUT_LORA + if (len < 4) return; + + uint16_t magic = (data[0] << 8) | data[1]; + if (magic != BRIDGE_PACKET_MAGIC) return; + + uint8_t decrypted[MAX_ESPNOW_PACKET_SIZE]; + int encLen = len - 2; // everything except magic + memcpy(decrypted, data + 2, encLen); + xorCrypt(decrypted, encLen); + + uint16_t rx_cksum = (decrypted[0] << 8) | decrypted[1]; + uint8_t* meshPayload = decrypted + 2; + int meshLen = encLen - 2; + + if (!validateChecksum(meshPayload, meshLen, rx_cksum)) return; + + memcpy(rx_buf, meshPayload, meshLen); + last_rx_len = meshLen; + #else + memcpy(rx_buf, data, len); + last_rx_len = len; + #endif } void ESPNOWRadio::init() { // Set device as a Wi-Fi Station WiFi.mode(WIFI_STA); + #ifdef CLIENT_WITHOUT_LORA + strncpy(bridge_secret, "LVSITANOS", sizeof(bridge_secret)); + #endif // Long Range mode esp_wifi_set_protocol(WIFI_IF_STA, WIFI_PROTOCOL_LR); @@ -75,13 +141,39 @@ uint32_t ESPNOWRadio::intID() { bool ESPNOWRadio::startSendRaw(const uint8_t* bytes, int len) { // Send message via ESP-NOW - is_send_complete = false; - esp_err_t result = esp_now_send(broadcastAddress, bytes, len); + #ifdef CLIENT_WITHOUT_LORA + if (!bytes || len <= 0) { + ESPNOW_DEBUG_PRINTLN("Invalid raw mesh packet"); + return false; + } + + if (len > (MAX_ESPNOW_PACKET_SIZE - 4)) { + ESPNOW_DEBUG_PRINTLN("Mesh packet too large for ESP-NOW"); + return false; + } + + uint8_t out[MAX_ESPNOW_PACKET_SIZE]; + out[0] = (BRIDGE_PACKET_MAGIC >> 8) & 0xFF; + out[1] = BRIDGE_PACKET_MAGIC & 0xFF; + + uint16_t cksum = fletcher16(bytes, len); + out[2] = (cksum >> 8) & 0xFF; + out[3] = cksum & 0xFF; + + memcpy(out + 4, bytes, len); + xorCrypt(out + 2, len + 2); + esp_err_t result = esp_now_send(broadcastAddress, out, len + 4); + #else + is_send_complete = false; + esp_err_t result = esp_now_send(broadcastAddress, bytes, len); + #endif + if (result == ESP_OK) { n_sent++; ESPNOW_DEBUG_PRINTLN("Send success"); return true; } + last_send_result = result; is_send_complete = true; ESPNOW_DEBUG_PRINTLN("Send failed: %d", result); diff --git a/src/helpers/esp32/SenseCapHAL.h b/src/helpers/esp32/SenseCapHAL.h new file mode 100644 index 0000000000..9a6f2f822c --- /dev/null +++ b/src/helpers/esp32/SenseCapHAL.h @@ -0,0 +1,307 @@ +#pragma once + +// SenseCapHAL - Custom RadioLib 7.x HAL for the Seeed SenseCAP Indicator +// +// The SenseCAP Indicator routes SX1262 control pins through a TCA9535 +// 16-bit I2C IO expander (address 0x20) because GPIOs 0-15 are used by +// the 16-bit RGB display bus. +// +// Pin encoding matches LovyanGFX convention: (pin_index | IO_EXPANDER) +// IO_EXPANDER = 0x40 (defined as build flag in platformio.ini) +// +// TCA9535 Port 0 pin assignments: +// pin 0 = NSS (EXPANDER_IO_RADIO_NSS) — SX1262 chip-select +// pin 1 = RESET (EXPANDER_IO_RADIO_RST) — SX1262 hardware reset +// pin 2 = BUSY (EXPANDER_IO_RADIO_BUSY) — SX1262 busy signal +// pin 3 = DIO1 (EXPANDER_IO_RADIO_DIO_1) — SX1262 IRQ +// pin 4 = display SPI CS — ST7701 chip-select (must stay OUTPUT HIGH) +// pin 5 = display RESX — ST7701 hardware reset (LovyanGFX cfg.pin_rst) +// pin 6 = touch INT — FT5x06 interrupt (input, not used in SW) +// pin 7 = touch RST — FT5x06 reset (not used in SW) +// +// DIO1 interrupt: TCA9535 /INT output → GPIO 42 (IO_EXPANDER_IRQ) +// The /INT pin fires FALLING when any input changes. +// +// TCA9535 register map (Port 0 only): +// 0x00 Input Port 0 (read) +// 0x02 Output Port 0 (write; 1=HIGH, 0=LOW) +// 0x06 Config Port 0 (0=output, 1=input) + +#include +#include +#include +#include +#include +#include + +class SenseCapHAL : public ArduinoHal { + TwoWire* _wire; + uint8_t _addr; // 7-bit I2C address of TCA9535 (0x20) + uint8_t _out0; // cached Output Port 0 latch (all HIGH = de-asserted) + uint8_t _cfg0; // cached Config Port 0 (all 1 = input initially) + int _sclk, _miso, _mosi; // SPI data pins + SemaphoreHandle_t _mutex; // shared Wire mutex (set via setMutex() after creation) + + // ── Deferred IRQ dispatch ────────────────────────────────────────────── + // The TCA9535 /INT fires for ANY input change on Port 0, not just DIO1. + // BUSY transitions, touch-INT (pin 6), and other inputs all trigger GPIO 42. + // We cannot do I2C inside an ISR, so the raw ISR just sets a flag. + // dispatchPendingIrq() (called from the main loop via recvRaw) reads Port 0 + // to verify DIO1 is actually HIGH before forwarding the event to RadioLib. + inline static volatile bool _s_pending = false; + inline static void (*_s_cb)(void) = nullptr; + uint8_t _irqBit = 0; // Port 0 bit-mask for DIO1, set in attachInterrupt() + + // NOTE: no IRAM_ATTR — class-static IRAM functions cause Xtensa literal-pool + // linker errors when defined inline in a header. Running from flash is fine + // here: the SenseCAP uses ESP32-S3 with no mid-operation flash cache disables, + // and LoRa packet timescales (tens of ms) dwarf any flash-cache miss latency. + static void _rawIsr() { _s_pending = true; } + + // A pin is on the expander when its upper nibble equals IO_EXPANDER + static bool isExp(uint32_t pin) { + return (pin & ~0x0Fu) == (uint32_t)IO_EXPANDER; + } + // Bit mask within TCA9535 port register + static uint8_t expBit(uint32_t pin) { + return (uint8_t)(1u << (pin & 0x07u)); + } + // Pins 0-7 are Port 0; pins 8-15 are Port 1 + static bool isPort0(uint32_t pin) { + return (pin & 0x08u) == 0; + } + + void writeReg(uint8_t reg, uint8_t val) { + if (_mutex) xSemaphoreTake(_mutex, portMAX_DELAY); + _wire->beginTransmission(_addr); + _wire->write(reg); + _wire->write(val); + _wire->endTransmission(); + if (_mutex) xSemaphoreGive(_mutex); + } + uint8_t readReg(uint8_t reg) { + if (_mutex) xSemaphoreTake(_mutex, portMAX_DELAY); + _wire->beginTransmission(_addr); + _wire->write(reg); + _wire->endTransmission(false); + _wire->requestFrom(_addr, (uint8_t)1); + uint8_t val = _wire->available() ? _wire->read() : 0xFF; + if (_mutex) xSemaphoreGive(_mutex); + return val; + } + +public: + SenseCapHAL(SPIClass& spi, int sclk, int miso, int mosi, + uint8_t i2c_addr = 0x20, TwoWire* wire = &Wire) + : ArduinoHal(spi, SPISettings(2000000, MSBFIRST, SPI_MODE0)) + , _wire(wire), _addr(i2c_addr) + , _out0(0xFF) // all HIGH (NSS, RESET de-asserted) + , _cfg0(0xFF) // all inputs initially + , _sclk(sclk), _miso(miso), _mosi(mosi) + , _mutex(nullptr) + {} + + // Set the shared I2C mutex. Must be called before any Wire operations. + // Both this HAL and the touch-read callback must use the same handle. + void setMutex(SemaphoreHandle_t m) { _mutex = m; } + + // Call once Wire is running, AFTER lcd.begin() has completed. + // Configures TCA9535 Port 0 radio pins (bits 0-3) and locks bit 4 (display CS). + // Bits 5-7 are preserved exactly as LovyanGFX left them. + void initExpander() { + // Read the current register values set by LovyanGFX + uint8_t cur_out = readReg(0x02); + uint8_t cur_cfg = readReg(0x06); + + // Bits 0-3 (radio): inputs initially; RadioLib reconfigures as needed. + // Output latch HIGH = de-asserted. + // Bit 4 (display CS): OUTPUT HIGH — permanently de-asserted. + // LovyanGFX leaves this as INPUT after lcd.begin(); + // a floating CS allows radio SPI to corrupt the ST7701. + // Bit 5 (display RESX): preserved as OUTPUT HIGH — lcd.begin() already pulsed + // it LOW→HIGH to reset the ST7701 before init commands. + // Bits 6-7 (touch INT/RST): preserved as LovyanGFX left them (inputs). + _out0 = (cur_out & 0xE0) | 0x1F; // bits 0-4 = HIGH, bits 5-7 = preserved + _cfg0 = (cur_cfg & 0xE0) | 0x0F; // bits 0-3 = input, bit 4 = OUTPUT, bits 5-7 = preserved + + writeReg(0x02, _out0); // Output Port 0 + writeReg(0x06, _cfg0); // Config Port 0 + + // Port 1 (pins 8-15) — appears unused on the SenseCAP Indicator. + // TCA9535 /INT fires on ANY input change on either port and only clears + // when the triggering port register is read. Floating Port 1 inputs + // continuously re-assert /INT, preventing DIO1 edges from ever firing. + // Fix: make all Port 1 pins OUTPUT HIGH so they can never float. + writeReg(0x03, 0xFF); // Output Port 1: all HIGH + writeReg(0x07, 0x00); // Config Port 1: all OUTPUTS + + // Read both input ports now to establish a clean /INT baseline. + readReg(0x00); + readReg(0x01); + + Serial.printf("[SenseCapHAL] TCA9535@0x%02X init: out0=0x%02X cfg0=0x%02X\n", + _addr, _out0, _cfg0); + } + + // ── Overrides ────────────────────────────────────────────────────────── + // + // SOFTWARE (bit-bang) SPI — intentionally avoids the hardware FSPI peripheral. + // + // Calling SPI.begin() (hardware FSPI) AFTER lcd.begin() disrupts the + // LCD_CAM peripheral that is already running the RGB parallel bus, + // causing the display to go blank. Since the LCD_CAM uses GPIOs 0–21 + // and the SX1262 SPI uses GPIOs 41/47/48, there is no pin conflict — + // the problem is at the peripheral / DMA level when FSPI is initialised + // while LCD_CAM is active. + // + // Bit-bang SPI on the same GPIOs avoids hardware SPI entirely. + // The SX1262 requires at most ~16 MHz SPI; bit-bang on ESP32-S3 gives + // ~1–2 MHz which is more than adequate for LoRa configuration and DIO + // interrupt latency is unaffected. + + // ArduinoHal::init() only calls spiBegin() when initInterface==true, + // which is false when an explicit SPIClass& is supplied. Override to + // always call our spiBegin(). + void init() override { spiBegin(); } + + void spiBegin() override { + // Configure GPIO pins for direct CPU control (disconnects any + // peripheral / GPIO-matrix function, including leftover FSPI routing). + ::pinMode(_sclk, OUTPUT); + ::pinMode(_mosi, OUTPUT); + ::pinMode(_miso, INPUT); + ::digitalWrite(_sclk, LOW); + Serial.printf("[SenseCapHAL] SPI (bit-bang) SCLK=%d MOSI=%d MISO=%d\n", + _sclk, _mosi, _miso); + } + + void spiEnd() override { + // nothing to tear down for bit-bang + } + + void spiBeginTransaction() override { + // nothing needed — CS is managed via the expander in digitalWrite() + } + + void spiEndTransaction() override { + // nothing needed + } + + // Bit-bang SPI Mode 0 (CPOL=0, CPHA=0): data sampled on rising edge. + void spiTransfer(uint8_t* out, size_t len, uint8_t* in) override { + for (size_t i = 0; i < len; i++) { + uint8_t tx = out ? out[i] : 0x00; + uint8_t rx = 0; + for (int b = 7; b >= 0; b--) { + ::digitalWrite(_mosi, (tx >> b) & 1); + ::digitalWrite(_sclk, HIGH); + rx = (rx << 1) | (::digitalRead(_miso) ? 1 : 0); + ::digitalWrite(_sclk, LOW); + } + if (in) in[i] = rx; + } + } + + void pinMode(uint32_t pin, uint32_t mode) override { + if (isExp(pin) && isPort0(pin)) { + if (mode == OUTPUT) _cfg0 &= ~expBit(pin); + else _cfg0 |= expBit(pin); + writeReg(0x06, _cfg0); + } else { + ArduinoHal::pinMode(pin, mode); + } + } + + void digitalWrite(uint32_t pin, uint32_t value) override { + if (isExp(pin) && isPort0(pin)) { + if (value) _out0 |= expBit(pin); + else _out0 &= ~expBit(pin); + writeReg(0x02, _out0); + } else { + ArduinoHal::digitalWrite(pin, value); + } + } + + uint32_t digitalRead(uint32_t pin) override { + if (isExp(pin) && isPort0(pin)) { + return (readReg(0x00) & expBit(pin)) ? 1 : 0; + } + return ArduinoHal::digitalRead(pin); + } + + // DIO1 is expander pin 3; redirect the interrupt to IO_EXPANDER_IRQ (GPIO 42). + // TCA9535 /INT fires FALLING when any input changes (DIO1 going HIGH = packet ready). + // RadioLib 7.x calls pinToInterrupt(irq_pin) BEFORE attachInterrupt(). + // Without this override, pinToInterrupt(0x43) → digitalPinToInterrupt(67) + // which is invalid on ESP32-S3, so attachInterrupt() silently fails. + // Return IO_EXPANDER_IRQ (GPIO 42) directly for any expander pin. + uint32_t pinToInterrupt(uint32_t pin) override { + if (isExp(pin)) { + return (uint32_t)IO_EXPANDER_IRQ; + } + return ArduinoHal::pinToInterrupt(pin); + } + + // Called with either: + // a) raw expander pin (e.g. 0x43) — direct call path + // b) IO_EXPANDER_IRQ (42) — via pinToInterrupt() path (RadioLib 7.x) + // + // DEFERRED DISPATCH: instead of calling `cb` (= RadioLib's setFlag) directly + // from the ISR, we attach a lightweight raw ISR that only sets _s_pending. + // The real dispatch (reading Port 0 to verify DIO1 is HIGH) happens later + // in dispatchPendingIrq(), called from the main loop via recvRaw(). + // This prevents touch-INT (pin 6), BUSY, and other Port 0 input changes + // from triggering false radio-interrupt events. + void attachInterrupt(uint32_t pin, void (*cb)(void), uint32_t mode) override { + if (isExp(pin) || pin == (uint32_t)IO_EXPANDER_IRQ) { + _s_cb = cb; // save RadioLib's setFlag callback + _irqBit = isExp(pin) ? expBit(pin) // direct expander pin → derive bit + : (uint8_t)(1u << 3u); // pin=42 path → DIO1 is bit 3 + // Clear any pending TCA9535 /INT by reading BOTH port registers. + readReg(0x00); + readReg(0x01); + ::pinMode(IO_EXPANDER_IRQ, INPUT_PULLUP); + int gpio42 = ::digitalRead(IO_EXPANDER_IRQ); + ::attachInterrupt(digitalPinToInterrupt(IO_EXPANDER_IRQ), _rawIsr, FALLING); + Serial.printf("[SenseCapHAL] DIO1 interrupt → GPIO %d state=%d (FALLING, deferred)\n", + IO_EXPANDER_IRQ, gpio42); + } else { + ArduinoHal::attachInterrupt(pin, cb, mode); + } + } + + // ── dispatchPendingIrq ──────────────────────────────────────────────── + // Call from the main loop (NOT from ISR). Reads Port 0 to check whether + // DIO1 is actually HIGH. If so, forwards the event to RadioLib (setFlag). + // Ignores spurious triggers from BUSY, touch-INT, or any other Port 0 input. + void dispatchPendingIrq() { + if (!_s_pending) return; + _s_pending = false; + + // Reading Port 0 also acknowledges the TCA9535 /INT for ALL inputs, + // including touch INT and BUSY — preventing /INT from staying stuck LOW. + uint8_t port0 = readReg(0x00); + if (_irqBit && (port0 & _irqBit)) { + // DIO1 is HIGH → this is a real radio interrupt (RX_DONE or TX_DONE) + if (_s_cb) _s_cb(); + } + // else: spurious — BUSY transition, touch INT, etc. Do nothing. + } + + void detachInterrupt(uint32_t pin) override { + if (isExp(pin) || pin == (uint32_t)IO_EXPANDER_IRQ) { + ::detachInterrupt(digitalPinToInterrupt(IO_EXPANDER_IRQ)); + } else { + ArduinoHal::detachInterrupt(pin); + } + } + + // Scan for the TCA9535 on I2C and log the result + bool scanExpander() { + if (_mutex) xSemaphoreTake(_mutex, portMAX_DELAY); + _wire->beginTransmission(_addr); + bool found = (_wire->endTransmission() == 0); + if (_mutex) xSemaphoreGive(_mutex); + return found; + } +}; diff --git a/src/helpers/esp32/SenseCapSX1262Wrapper.h b/src/helpers/esp32/SenseCapSX1262Wrapper.h new file mode 100644 index 0000000000..3e19e5cbb9 --- /dev/null +++ b/src/helpers/esp32/SenseCapSX1262Wrapper.h @@ -0,0 +1,27 @@ +#pragma once + +// SenseCapSX1262Wrapper — extends CustomSX1262Wrapper with a DIO1-verified +// dispatchPendingIrq() override. +// +// On SenseCAP Indicator the SX1262 DIO1, BUSY, and touch-INT all share the +// same TCA9535 /INT line (GPIO 42). The raw ISR in SenseCapHAL only sets a +// pending flag; this override reads Port 0 via I2C and calls setFlag() only +// when DIO1 is actually HIGH, silencing spurious triggers from BUSY +// transitions, touch events, or any other Port 0 input change. + +#include +#include "SenseCapHAL.h" + +class SenseCapSX1262Wrapper : public CustomSX1262Wrapper { +public: + SenseCapSX1262Wrapper(CustomSX1262& radio, mesh::MainBoard& board) + : CustomSX1262Wrapper(radio, board) {} + +protected: + void dispatchPendingIrq() override { + // Access HAL via Module (Module::hal is public in RadioLib 7.x) + auto* hal = static_cast( + static_cast(_radio)->getMod()->hal); + hal->dispatchPendingIrq(); + } +}; diff --git a/src/helpers/radiolib/RadioLibWrappers.cpp b/src/helpers/radiolib/RadioLibWrappers.cpp index b6519aefa7..b644aee346 100644 --- a/src/helpers/radiolib/RadioLibWrappers.cpp +++ b/src/helpers/radiolib/RadioLibWrappers.cpp @@ -57,7 +57,11 @@ void RadioLibWrapper::idle() { void RadioLibWrapper::triggerNoiseFloorCalibrate(int threshold) { _threshold = threshold; - if (_num_floor_samples >= NUM_NOISE_FLOOR_SAMPLES) { // ignore trigger if currently sampling + // Only restart sampling when threshold > 0 (interference detection enabled). + // With threshold=0 the noise floor is never used, so periodic SPI re-sampling + // is pointless — and on boards with a shared-bus IRQ (e.g. TCA9535) the BUSY + // transitions generated by those SPI calls fire spurious interrupts that break RX. + if (threshold > 0 && _num_floor_samples >= NUM_NOISE_FLOOR_SAMPLES) { _num_floor_samples = 0; _floor_sample_sum = 0; } @@ -117,9 +121,15 @@ bool RadioLibWrapper::isInRecvMode() const { } int RadioLibWrapper::recvRaw(uint8_t* bytes, int sz) { + // Allow subclasses to gate STATE_INT_READY on the physical IRQ pin. + // On boards with a shared-bus /INT (e.g. TCA9535), this reads DIO1 + // via I2C and only sets STATE_INT_READY when the radio actually asserted it. + dispatchPendingIrq(); + int len = 0; if (state & STATE_INT_READY) { len = _radio->getPacketLength(); + MESH_DEBUG_PRINTLN("RadioLibWrapper: IRQ fired, pkt_len=%d", len); if (len > 0) { if (len > sz) { len = sz; } int err = _radio->readData(bytes, len); @@ -128,7 +138,7 @@ int RadioLibWrapper::recvRaw(uint8_t* bytes, int sz) { len = 0; n_recv_errors++; } else { - // Serial.print(" readData() -> "); Serial.println(len); + MESH_DEBUG_PRINTLN("RadioLibWrapper: recv %d bytes RSSI=%.1f SNR=%.1f", len, getLastRSSI(), getLastSNR()); n_recv++; } } @@ -136,9 +146,16 @@ int RadioLibWrapper::recvRaw(uint8_t* bytes, int sz) { } if (state != STATE_RX) { + // Note: we intentionally do NOT call isReceivingPacket() here. + // On boards where DIO1/BUSY share a TCA9535 /INT line, isReceivingPacket() + // does an SPI read which generates another BUSY pulse → another spurious + // interrupt → infinite pkt_len=0 loop. Calling startReceive() unconditionally + // is safe: if pkt_len was 0 the packet was not yet complete (or the interrupt + // was fully spurious), so restarting RX is correct. int err = _radio->startReceive(); if (err == RADIOLIB_ERR_NONE) { state = STATE_RX; + state &= ~STATE_INT_READY; // BUSY transitions during startReceive fire TCA9535 /INT spuriously } else { MESH_DEBUG_PRINTLN("RadioLibWrapper: error: startReceive(%d)", err); } diff --git a/src/helpers/radiolib/RadioLibWrappers.h b/src/helpers/radiolib/RadioLibWrappers.h index efd3e17931..8dee0f3eac 100644 --- a/src/helpers/radiolib/RadioLibWrappers.h +++ b/src/helpers/radiolib/RadioLibWrappers.h @@ -19,6 +19,14 @@ class RadioLibWrapper : public mesh::Radio { virtual bool isReceivingPacket() =0; virtual void doResetAGC(); + // Called at the start of recvRaw() before checking STATE_INT_READY. + // Override on boards where the radio IRQ line is shared with other inputs + // (e.g. TCA9535 Port 0 also carries BUSY and touch INT). The override + // must read the physical IRQ pin and, ONLY if the radio has actually + // asserted it, call setFlag() to set STATE_INT_READY. Default: no-op + // (interrupt-driven boards set STATE_INT_READY directly in the ISR). + virtual void dispatchPendingIrq() {} + public: RadioLibWrapper(PhysicalLayer& radio, mesh::MainBoard& board) : _radio(&radio), _board(&board), _preamble_sf(0) { n_recv = n_sent = 0; } diff --git a/variants/generic-e22/variant.h b/variants/generic-e22/variant.h index 6c850af262..57207ed30c 100644 --- a/variants/generic-e22/variant.h +++ b/variants/generic-e22/variant.h @@ -19,7 +19,7 @@ // Radio #define USE_SX1262 // E22-900M30S uses SX1262 #define USE_SX1268 // E22-400M30S uses SX1268 -#define SX126X_MAX_POWER 22 // Outputting 22dBm from SX1262 results in ~30dBm E22-900M30S output (module only uses last stage of the YP2233W PA) +#define SX126X_MAX_POWER 27 // Outputting 22dBm from SX1262 results in ~30dBm E22-900M30S output (module only uses last stage of the YP2233W PA) #define SX126X_DIO3_TCXO_VOLTAGE 1.8 // E22 series TCXO reference voltage is 1.8V #define SX126X_CS 18 // EBYTE module's NSS pin diff --git a/variants/lilygo_teth_elite/TETHEliteBoard.h b/variants/lilygo_teth_elite/TETHEliteBoard.h new file mode 100644 index 0000000000..15eb9533ef --- /dev/null +++ b/variants/lilygo_teth_elite/TETHEliteBoard.h @@ -0,0 +1,10 @@ +#pragma once + +#include + +class TETHEliteBoard : public ESP32Board { +public: + const char* getManufacturerName() const override { + return "LilyGO T-ETH Elite"; + } +}; diff --git a/variants/lilygo_teth_elite/platformio.ini b/variants/lilygo_teth_elite/platformio.ini new file mode 100644 index 0000000000..97728f8b4c --- /dev/null +++ b/variants/lilygo_teth_elite/platformio.ini @@ -0,0 +1,99 @@ +[LilyGo_TETH_Elite_sx1262] +extends = esp32_base +board = esp32s3box +board_build.partitions = default_16MB.csv +board_upload.flash_size = 16MB +build_flags = + ${esp32_base.build_flags} + -I variants/lilygo_teth_elite + -D BOARD_HAS_PSRAM + -D LILYGO_TETH_ELITE + -D LILYGO_T_ETH_ELITE_ESP32S3 + -D ARDUINO_USB_CDC_ON_BOOT=1 + -D P_LORA_DIO_1=8 + -D P_LORA_NSS=40 + -D P_LORA_RESET=46 + -D P_LORA_BUSY=16 + -D P_LORA_SCLK=10 + -D P_LORA_MISO=9 + -D P_LORA_MOSI=11 + -D P_LORA_TX_LED=38 + -D SX126X_DIO2_AS_RF_SWITCH=true + -D SX126X_DIO3_TCXO_VOLTAGE=1.8 + -D SX126X_CURRENT_LIMIT=140 + -D USE_SX1262 + -D RADIO_CLASS=CustomSX1262 + -D WRAPPER_CLASS=CustomSX1262Wrapper + -D LORA_TX_POWER=8 + -D SX126X_RX_BOOSTED_GAIN=1 +build_src_filter = ${esp32_base.build_src_filter} + +<../variants/lilygo_teth_elite> +lib_deps = + ${esp32_base.lib_deps} + +[env:LilyGo_TETH_Elite_sx1262_repeater] +extends = LilyGo_TETH_Elite_sx1262 +build_flags = + ${LilyGo_TETH_Elite_sx1262.build_flags} + -D ADVERT_NAME='"T-ETH Elite Repeater"' + -D ADVERT_LAT=0.0 + -D ADVERT_LON=0.0 + -D ADMIN_PASSWORD='"password"' + -D MAX_NEIGHBOURS=50 +; -D MESH_PACKET_LOGGING=1 +; -D MESH_DEBUG=1 +build_src_filter = ${LilyGo_TETH_Elite_sx1262.build_src_filter} + +<../examples/simple_repeater> +lib_deps = + ${LilyGo_TETH_Elite_sx1262.lib_deps} + ${esp32_ota.lib_deps} + +[env:LilyGo_TETH_Elite_sx1262_room_server] +extends = LilyGo_TETH_Elite_sx1262 +build_flags = + ${LilyGo_TETH_Elite_sx1262.build_flags} + -D ADVERT_NAME='"T-ETH Elite Room"' + -D ADVERT_LAT=0.0 + -D ADVERT_LON=0.0 + -D ADMIN_PASSWORD='"password"' + -D ROOM_PASSWORD='"hello"' +; -D MESH_PACKET_LOGGING=1 +; -D MESH_DEBUG=1 +build_src_filter = ${LilyGo_TETH_Elite_sx1262.build_src_filter} + +<../examples/simple_room_server> +lib_deps = + ${LilyGo_TETH_Elite_sx1262.lib_deps} + ${esp32_ota.lib_deps} + +[env:LilyGo_TETH_Elite_sx1262_companion_radio_usb] +extends = LilyGo_TETH_Elite_sx1262 +build_flags = + ${LilyGo_TETH_Elite_sx1262.build_flags} + -D MAX_CONTACTS=350 + -D MAX_GROUP_CHANNELS=40 + -D OFFLINE_QUEUE_SIZE=256 +; -D MESH_PACKET_LOGGING=1 +; -D MESH_DEBUG=1 +build_src_filter = ${LilyGo_TETH_Elite_sx1262.build_src_filter} + +<../examples/companion_radio/*.cpp> +lib_deps = + ${LilyGo_TETH_Elite_sx1262.lib_deps} + densaugeo/base64 @ ~1.4.0 + +[env:LilyGo_TETH_Elite_sx1262_companion_radio_ble] +extends = LilyGo_TETH_Elite_sx1262 +build_flags = + ${LilyGo_TETH_Elite_sx1262.build_flags} + -D MAX_CONTACTS=350 + -D MAX_GROUP_CHANNELS=40 + -D BLE_PIN_CODE=123456 + -D BLE_DEBUG_LOGGING=1 + -D OFFLINE_QUEUE_SIZE=256 +; -D MESH_PACKET_LOGGING=1 +; -D MESH_DEBUG=1 +build_src_filter = ${LilyGo_TETH_Elite_sx1262.build_src_filter} + + + +<../examples/companion_radio/*.cpp> +lib_deps = + ${LilyGo_TETH_Elite_sx1262.lib_deps} + densaugeo/base64 @ ~1.4.0 diff --git a/variants/lilygo_teth_elite/target.cpp b/variants/lilygo_teth_elite/target.cpp new file mode 100644 index 0000000000..4dc377d620 --- /dev/null +++ b/variants/lilygo_teth_elite/target.cpp @@ -0,0 +1,43 @@ +#include +#include "target.h" + +TETHEliteBoard board; + +static SPIClass spi(HSPI); +RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_1, P_LORA_RESET, P_LORA_BUSY, spi); +WRAPPER_CLASS radio_driver(radio, board); + +ESP32RTCClock fallback_clock; +AutoDiscoverRTCClock rtc_clock(fallback_clock); +SensorManager sensors; + +#ifndef LORA_CR + #define LORA_CR 5 +#endif + +bool radio_init() { + fallback_clock.begin(); + rtc_clock.begin(Wire); + + return radio.std_init(&spi); +} + +uint32_t radio_get_rng_seed() { + return radio.random(0x7FFFFFFF); +} + +void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr) { + radio.setFrequency(freq); + radio.setSpreadingFactor(sf); + radio.setBandwidth(bw); + radio.setCodingRate(cr); +} + +void radio_set_tx_power(int8_t dbm) { + radio.setOutputPower(dbm); +} + +mesh::LocalIdentity radio_new_identity() { + RadioNoiseListener rng(radio); + return mesh::LocalIdentity(&rng); +} diff --git a/variants/lilygo_teth_elite/target.h b/variants/lilygo_teth_elite/target.h new file mode 100644 index 0000000000..a842186cf6 --- /dev/null +++ b/variants/lilygo_teth_elite/target.h @@ -0,0 +1,20 @@ +#pragma once + +#define RADIOLIB_STATIC_ONLY 1 +#include +#include +#include +#include +#include +#include "TETHEliteBoard.h" + +extern TETHEliteBoard board; +extern WRAPPER_CLASS radio_driver; +extern AutoDiscoverRTCClock rtc_clock; +extern SensorManager sensors; + +bool radio_init(); +uint32_t radio_get_rng_seed(); +void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr); +void radio_set_tx_power(int8_t dbm); +mesh::LocalIdentity radio_new_identity(); diff --git a/variants/meshadventurer/variant.h b/variants/meshadventurer/variant.h index 356a3e172f..f075afccaa 100644 --- a/variants/meshadventurer/variant.h +++ b/variants/meshadventurer/variant.h @@ -19,7 +19,7 @@ // Radio #define USE_SX1262 // E22-900M30S uses SX1262 #define USE_SX1268 // E22-400M30S uses SX1268 -#define SX126X_MAX_POWER 22 // Outputting 22dBm from SX1262 results in ~30dBm E22-900M30S output (module only uses last stage of the YP2233W PA) +#define SX126X_MAX_POWER 27 // Outputting 22dBm from SX1262 results in ~30dBm E22-900M30S output (module only uses last stage of the YP2233W PA) #define SX126X_DIO3_TCXO_VOLTAGE 1.8 // E22 series TCXO reference voltage is 1.8V #define SX126X_CS 18 // EBYTE module's NSS pin diff --git a/variants/sensecap_indicator-espnow/1.jpg b/variants/sensecap_indicator-espnow/1.jpg new file mode 100644 index 0000000000..3fe0c8240f Binary files /dev/null and b/variants/sensecap_indicator-espnow/1.jpg differ diff --git a/variants/sensecap_indicator-espnow/2.jpg b/variants/sensecap_indicator-espnow/2.jpg new file mode 100644 index 0000000000..41350a19b7 Binary files /dev/null and b/variants/sensecap_indicator-espnow/2.jpg differ diff --git a/variants/sensecap_indicator-espnow/3.jpg b/variants/sensecap_indicator-espnow/3.jpg new file mode 100644 index 0000000000..c5cdc3f86c Binary files /dev/null and b/variants/sensecap_indicator-espnow/3.jpg differ diff --git a/variants/sensecap_indicator-espnow/4.jpg b/variants/sensecap_indicator-espnow/4.jpg new file mode 100644 index 0000000000..1e852544ab Binary files /dev/null and b/variants/sensecap_indicator-espnow/4.jpg differ diff --git a/variants/sensecap_indicator-espnow/SCIndicatorDisplay.h b/variants/sensecap_indicator-espnow/SCIndicatorDisplay.h index aabedd2401..fd708e10b9 100644 --- a/variants/sensecap_indicator-espnow/SCIndicatorDisplay.h +++ b/variants/sensecap_indicator-espnow/SCIndicatorDisplay.h @@ -8,9 +8,35 @@ #include #include +// Custom ST7701 panel subclass with SenseCap Indicator-specific init commands. +// The default Panel_ST7701 init sequence does not set MADCTL or SDIR, so the +// display outputs pixels in an orientation that doesn't match the physical +// RGB bus wiring on the SenseCap Indicator — resulting in a blank screen. +// These extra commands (ported from Meshtastic's LGFX_INDICATOR.h) apply the +// required vertical flip (MADCTL) and horizontal flip (SDIR) after the +// standard init sequence. +class Panel_SCIndicator : public lgfx::Panel_ST7701 +{ +public: + const uint8_t *getInitCommands(uint8_t listno) const override + { + static constexpr const uint8_t list1[] = { + 0x36, 1, 0x10, // MADCTL: vertical flip + 0xFF, 5, 0x77, 0x01, 0x00, 0x00, 0x10, // Command2 BK0 SEL + 0xC7, 1, 0x04, // SDIR: horizontal flip + 0xFF, 5, 0x77, 0x01, 0x00, 0x00, 0x00, // Command2 BK0 DIS + 0xFF, 0xFF + }; + switch (listno) { + case 1: return list1; + default: return lgfx::Panel_ST7701::getInitCommands(listno); + } + } +}; + class LGFX : public lgfx::LGFX_Device { - lgfx::Panel_ST7701 _panel_instance; + Panel_SCIndicator _panel_instance; lgfx::Bus_RGB _bus_instance; lgfx::Light_PWM _light_instance; lgfx::Touch_FT5x06 _touch_instance; @@ -31,13 +57,16 @@ class LGFX : public lgfx::LGFX_Device cfg.panel_height = screenHeight; cfg.offset_x = 0; cfg.offset_y = 0; - cfg.offset_rotation = 1; + cfg.offset_rotation = 0; + // pin_rst stays at default (no-connect). Upstream LovyanGFX cannot + // toggle expander pins. The ST7701 RESX (TCA9535 bit 5) is pulsed + // manually by sensecap_lcd_reset_pulse() in main.cpp before lcd.begin(). _panel_instance.config(cfg); } { auto cfg = _panel_instance.config_detail(); - cfg.pin_cs = 4 | IO_EXPANDER; + cfg.pin_cs = 4 | IO_EXPANDER; // TCA9535 bit 4 = ST7701 chip-select cfg.pin_sclk = 41; cfg.pin_mosi = 48; cfg.use_psram = 1; @@ -48,7 +77,7 @@ class LGFX : public lgfx::LGFX_Device auto cfg = _bus_instance.config(); cfg.panel = &_panel_instance; - cfg.freq_write = 8000000; + cfg.freq_write = 6000000; // 6 MHz — matches Meshtastic LGFX_INDICATOR cfg.pin_henable = 18; cfg.pin_pclk = 21; @@ -103,10 +132,10 @@ class LGFX : public lgfx::LGFX_Device cfg.x_max = 479; cfg.y_min = 0; cfg.y_max = 479; - cfg.pin_int = GPIO_NUM_NC; - cfg.pin_rst = GPIO_NUM_NC; - cfg.bus_shared = true; - cfg.offset_rotation = 0; + cfg.pin_int = GPIO_NUM_NC; // do NOT use IO_EXPANDER for touch pins + cfg.pin_rst = GPIO_NUM_NC; // do NOT use IO_EXPANDER for touch pins + cfg.bus_shared = false; + cfg.offset_rotation = 2; // 180° — mirrors Meshtastic bbct.setOrientation(180,480,480) cfg.i2c_port = 0; cfg.i2c_addr = 0x48; diff --git a/variants/sensecap_indicator-espnow/platformio.ini b/variants/sensecap_indicator-espnow/platformio.ini index e643d03398..404f9b930b 100644 --- a/variants/sensecap_indicator-espnow/platformio.ini +++ b/variants/sensecap_indicator-espnow/platformio.ini @@ -6,7 +6,7 @@ board_build.flash_mode = qio board_build.psram_type = opi board_upload.flash_size = 8MB board_upload.maximum_size = 8388608 -board_build.partitions = default.csv +board_build.partitions = partition-table-8MB.csv build_flags = ${esp32_base.build_flags} -D PIN_BOARD_SDA=39 @@ -36,15 +36,40 @@ lib_deps=${esp32_base.lib_deps} extends =SenseCapIndicator-ESPNow build_flags = ${SenseCapIndicator-ESPNow.build_flags} - -I examples/companion_radio/ui-new + ; -I examples/companion_radio/ui-new -D MAX_CONTACTS=350 -D MAX_GROUP_CHANNELS=40 + -D CORE_DEBUG_LEVEL=4 ; 0: None, 1: Error, 2: Warn, 3: Info, 4: Debug, 5: Verbose + -D LV_CONF_PATH=lv_conf.h + -D SEEED_SENSECAP_INDICATOR + -D RADIO_CLASS=CustomSX1262 + -D WRAPPER_CLASS=SenseCapSX1262Wrapper + -D PIN_USER_BTN=38 + -D LANG_EN + -D LORA_FREQ=869.525 + -D LORA_BW=250.0 + -D LORA_SF=11 + -D LORA_CR=5 + -D LORA_TX_POWER=20 + -D SX126X_DIO3_TCXO_VOLTAGE=2.4 + -D SX126X_DIO2_AS_RF_SWITCH=true + -D ADVERT_NAME='"SenseCap Client"' + -D MAX_CONTACTS=350 + -D MAX_GROUP_CHANNELS=8 + -D MESH_DEBUG=1 + -D RADIOLIB_SPI_PARANOID=0 + ; NOTE: DO NOT ENABLE --> -D MESH_PACKET_LOGGING=1 ; NOTE: DO NOT ENABLE --> -D MESH_DEBUG=1 ; NOTE: DO NOT ENABLE --> -D ESPNOW_DEBUG_LOGGING=1 build_src_filter = ${SenseCapIndicator-ESPNow.build_src_filter} - +<../examples/companion_radio/ui-new/*.cpp> - +<../examples/companion_radio/*.cpp> + +<../examples/simple_secure_chat_ui/*.cpp> + + + + lib_deps = ${SenseCapIndicator-ESPNow.lib_deps} - densaugeo/base64 @ ~1.4.0 \ No newline at end of file + fbiego/ESP32Time@^2.0.6 + lvgl/lvgl@8.3.11 + lovyan03/LovyanGFX@^1.2.7 + bitbank2/PNGdec@^1.1.6 + densaugeo/base64 @ ~1.4.0 diff --git a/variants/sensecap_indicator-espnow/target.cpp b/variants/sensecap_indicator-espnow/target.cpp index c84d1883e7..e4cb1f9454 100644 --- a/variants/sensecap_indicator-espnow/target.cpp +++ b/variants/sensecap_indicator-espnow/target.cpp @@ -1,44 +1,169 @@ #include #include "target.h" -#include +#include + +// Recover a stuck I2C bus by manually clocking SCL up to 9 times until +// SDA is released, then issuing a STOP condition. +static void i2c_bus_recovery() { + Serial.println("[i2c_recover] Attempting I2C bus recovery..."); + pinMode(PIN_BOARD_SCL, OUTPUT_OPEN_DRAIN); + pinMode(PIN_BOARD_SDA, INPUT_PULLUP); + digitalWrite(PIN_BOARD_SCL, HIGH); + delayMicroseconds(10); + + bool released = false; + for (int i = 0; i < 9; i++) { + digitalWrite(PIN_BOARD_SCL, LOW); + delayMicroseconds(10); + digitalWrite(PIN_BOARD_SCL, HIGH); + delayMicroseconds(10); + if (digitalRead(PIN_BOARD_SDA) == HIGH) { + released = true; + Serial.printf("[i2c_recover] SDA released after %d clocks\n", i + 1); + break; + } + } + if (!released) { + Serial.println("[i2c_recover] SDA still LOW after 9 clocks!"); + } + + // Generate STOP condition: SDA LOW→HIGH while SCL HIGH + pinMode(PIN_BOARD_SDA, OUTPUT_OPEN_DRAIN); + digitalWrite(PIN_BOARD_SDA, LOW); + delayMicroseconds(10); + digitalWrite(PIN_BOARD_SCL, HIGH); + delayMicroseconds(10); + digitalWrite(PIN_BOARD_SDA, HIGH); + delayMicroseconds(10); + + // Restore pins to input so Wire can take over + pinMode(PIN_BOARD_SCL, INPUT_PULLUP); + pinMode(PIN_BOARD_SDA, INPUT_PULLUP); + delay(5); + Serial.println("[i2c_recover] Done."); +} ESP32Board board; -ESPNOWRadio radio_driver; +// ── SX1262 SPI data pins (hardware FSPI / SPI2) ──────────────────────── +// Shared with the ST7701 display config SPI (bit-banged by LovyanGFX only +// during lcd.begin(), so no runtime conflict). +#define LORA_SCLK 41 +#define LORA_MISO 47 +#define LORA_MOSI 48 + +// ── SX1262 control pins via TCA9535 I2C IO Expander (7-bit addr 0x20) ── +// Encoded as (pin_index | IO_EXPANDER) per LovyanGFX / Seeed convention. +// IO_EXPANDER = 0x40 and IO_EXPANDER_IRQ = 42 defined in platformio.ini +#define LORA_NSS (0 | IO_EXPANDER) // TCA9535 port-0 pin 0 (0x40) +#define LORA_RESET (1 | IO_EXPANDER) // TCA9535 port-0 pin 1 (0x41) +#define LORA_BUSY (2 | IO_EXPANDER) // TCA9535 port-0 pin 2 (0x42) +#define LORA_DIO1 (3 | IO_EXPANDER) // TCA9535 port-0 pin 3 (0x43) + // → interrupt fires on GPIO 42 -ESP32RTCClock rtc_clock; -#if defined(ENV_INCLUDE_GPS) -MicroNMEALocationProvider nmea = MicroNMEALocationProvider(Serial1, (mesh::RTCClock*)&rtc_clock); -EnvironmentSensorManager sensors = EnvironmentSensorManager(nmea); -#else -EnvironmentSensorManager sensors = EnvironmentSensorManager(); -#endif +// Custom RadioLib HAL: routes expander pins through TCA9535 (I2C 0x20). +// Uses software (bit-bang) SPI on SCLK/MOSI/MISO to avoid taking the +// hardware FSPI peripheral, which would disrupt LovyanGFX's LCD_CAM output. +// SPI is passed as a placeholder only — all SPI methods are overridden. +static SenseCapHAL radio_hal(SPI, LORA_SCLK, LORA_MISO, LORA_MOSI, 0x20, &Wire); -#ifdef DISPLAY_CLASS - DISPLAY_CLASS display; - #ifdef PIN_USER_BTN - MomentaryButton user_btn(PIN_USER_BTN, 1000, true, true); - #endif -#endif +// SX1262 module using the custom HAL +RADIO_CLASS radio = new Module(&radio_hal, LORA_NSS, LORA_DIO1, LORA_RESET, LORA_BUSY); + +WRAPPER_CLASS radio_driver(radio, board); + +ESP32RTCClock fallback_clock; +AutoDiscoverRTCClock rtc_clock(fallback_clock); + +EnvironmentSensorManager sensors; + +// Shared Wire mutex — created in radio_init(), exported via target.h +SemaphoreHandle_t g_i2c_mutex = nullptr; + +// ── radio_init ───────────────────────────────────────────────────────── bool radio_init() { - rtc_clock.begin(); + // Create the shared Wire mutex FIRST so both the radio HAL and the + // LVGL touch callback (my_touchpad_read) serialise their Wire access. + g_i2c_mutex = xSemaphoreCreateMutex(); + radio_hal.setMutex(g_i2c_mutex); - radio_driver.init(); + Serial.println("[radio_init] Starting..."); + Serial.printf("[radio_init] SPI : SCLK=%d MISO=%d MOSI=%d\n", + LORA_SCLK, LORA_MISO, LORA_MOSI); + Serial.printf("[radio_init] Expander (0x20): NSS=pin%d RST=pin%d BUSY=pin%d DIO1=pin%d\n", + LORA_NSS & 0x0F, LORA_RESET & 0x0F, LORA_BUSY & 0x0F, LORA_DIO1 & 0x0F); + Serial.printf("[radio_init] DIO1 interrupt → GPIO %d\n", IO_EXPANDER_IRQ); - return true; // success -} + // Take mutex for bus recovery + Wire re-init + scan + // (prevents LVGL touch task from accessing Wire concurrently) + xSemaphoreTake(g_i2c_mutex, portMAX_DELAY); + + // Recover stuck I2C bus (may be left in bad state after display init) + i2c_bus_recovery(); -// NOTE: as we are using the WiFi radio, the ESP_IDF will have enabled hardware RNG: -// https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-reference/system/random.html -class ESP_RNG : public mesh::RNG { -public: - void random(uint8_t* dest, size_t sz) override { - esp_fill_random(dest, sz); + // Wire must be up before TCA9535 access — force full re-init after recovery + Wire.end(); + delay(5); + Wire.begin(PIN_BOARD_SDA, PIN_BOARD_SCL, 400000); + Wire.setTimeOut(15); // 15 ms per address for fast scan + delay(10); + + // ── Full I2C bus scan ─────────────────────────────────────────────────── + Serial.println("[radio_init] I2C scan:"); + uint8_t found_addr = 0; + for (uint8_t addr = 0x08; addr <= 0x77; addr++) { + Wire.beginTransmission(addr); + uint8_t err = Wire.endTransmission(); + if (err == 0) { + Serial.printf("[radio_init] Device found at 0x%02X\n", addr); + found_addr = addr; + } + } + if (found_addr == 0) { + Serial.println("[radio_init] No I2C devices found!"); + } + Serial.println("[radio_init] I2C scan done."); + + xSemaphoreGive(g_i2c_mutex); + + // Verify TCA9535 is present on the bus + if (radio_hal.scanExpander()) { + Serial.println("[radio_init] TCA9535 FOUND at 0x20"); + } else { + Serial.println("[radio_init] WARNING: TCA9535 NOT FOUND at 0x20 – check I2C wiring"); } -}; + + // Set TCA9535 Port 0 defaults: all outputs HIGH (NSS/RESET de-asserted) + radio_hal.initExpander(); + + fallback_clock.begin(); + Serial.println("[radio_init] RTC initialized"); + + // std_init() calls radio.begin() internally, which calls our spiBegin() + // to initialise the FSPI bus with pins 41/47/48, then communicates with + // the SX1262 using our expander-aware digitalWrite/digitalRead. + bool ok = radio.std_init(); + Serial.printf("[radio_init] std_init result: %s\n", ok ? "OK" : "FAILED"); + return ok; +} + +uint32_t radio_get_rng_seed() { + return radio.random(0x7FFFFFFF); +} + +void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr) { + radio.setFrequency(freq); + radio.setSpreadingFactor(sf); + radio.setBandwidth(bw); + radio.setCodingRate(cr); +} + +void radio_set_tx_power(uint8_t dbm) { + radio.setOutputPower(dbm); +} mesh::LocalIdentity radio_new_identity() { - ESP_RNG rng; - return mesh::LocalIdentity(&rng); // create new random identity + RadioNoiseListener rng(radio); + return mesh::LocalIdentity(&rng); } diff --git a/variants/sensecap_indicator-espnow/target.h b/variants/sensecap_indicator-espnow/target.h index dab4575e5c..ddf7d82888 100644 --- a/variants/sensecap_indicator-espnow/target.h +++ b/variants/sensecap_indicator-espnow/target.h @@ -1,26 +1,78 @@ #pragma once +#include +#include +#include +#include +#include + #include -#include +#include +#include +#include +#include // TCA9535 IO expander HAL for RadioLib +#include // DIO1-verified IRQ dispatch + #include #include + #ifdef ENV_INCLUDE_GPS #include #endif + #ifdef DISPLAY_CLASS #include "SCIndicatorDisplay.h" #include #endif + +// ------------------------------------------------- +// Board +// ------------------------------------------------- extern ESP32Board board; -extern ESPNOWRadio radio_driver; -extern ESP32RTCClock rtc_clock; + + +// ------------------------------------------------- +// Radio (SX1262 - SenseCAP uses SX1262) +// ------------------------------------------------- +extern SenseCapSX1262Wrapper radio_driver; + + +// ------------------------------------------------- +// RTC +// ------------------------------------------------- +extern AutoDiscoverRTCClock rtc_clock; + + +// ------------------------------------------------- +// Sensors +// ------------------------------------------------- extern EnvironmentSensorManager sensors; + +// ------------------------------------------------- +// Display + Button +// ------------------------------------------------- #ifdef DISPLAY_CLASS extern DISPLAY_CLASS display; extern MomentaryButton user_btn; #endif + +// ------------------------------------------------- +// Shared I2C mutex +// Protects Wire access shared between SenseCapHAL (TCA9535 @ 0x20) +// and the LVGL touch callback (FT5x06 @ 0x48). +// Created in radio_init() before std_init(); use via g_i2c_mutex. +// ------------------------------------------------- +extern SemaphoreHandle_t g_i2c_mutex; + + +// ------------------------------------------------- +// Functions +// ------------------------------------------------- bool radio_init(); -mesh::LocalIdentity radio_new_identity(); +uint32_t radio_get_rng_seed(); +void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr); +void radio_set_tx_power(uint8_t dbm); +mesh::LocalIdentity radio_new_identity(); \ No newline at end of file